diff --git a/.changeset/eql-3-0-5-migration.md b/.changeset/eql-3-0-5-migration.md index 32bdea778..87688a540 100644 --- a/.changeset/eql-3-0-5-migration.md +++ b/.changeset/eql-3-0-5-migration.md @@ -3,18 +3,45 @@ --- Move the bundled EQL v3 migrations to **eql-3.0.5**, which renames the SQL -function `eql_v3.ste_vec_contains` to `eql_v3.jsonb_document_contains`. The -operators are unchanged (`@>` / `<@` on `public.eql_v3_json_search` behave -exactly as before) — only callers that invoke the function **by name** are -affected, which in practice means Supabase / PostgREST, since PostgREST calls -functions rather than operators. +function `eql_v3.ste_vec_contains` to `eql_v3.jsonb_document_contains`. + +**The blast radius is narrower than a renamed public function suggests.** The +`@>` / `<@` operators on `public.eql_v3_json_search` behave exactly as before, +and so do the two function-form entry points that exist for platforms without +operator support — `eql_v3.jsonb_contains(jsonb, jsonb)` and +`eql_v3.jsonb_contained_by(jsonb, jsonb)` are byte-identical to 3.0.4. Those +are what a PostgREST caller invokes, so PostgREST callers on the documented +surface are **not** affected. The renamed function is the typed implementation +those operators dispatch into. + +**And the old name still works.** eql-3.0.5 ships `eql_v3.ste_vec_contains` as +a deprecated delegating alias for both overloads, so hand-written SQL naming it +— an application query, a view, an RLS policy, or a per-function +`GRANT EXECUTE ON FUNCTION eql_v3.ste_vec_contains(…)` — keeps resolving. The +typed overload stays inlinable, so a function-form query through the alias +still matches the same functional GIN index. Migrate to +`jsonb_document_contains` when convenient; nothing forces it at upgrade time. + +**Separately — and true of every EQL upgrade, not just this one:** the install +bundle opens with `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so applying it +destroys every grant on every object in `eql_v3` / `eql_v3_internal`, along +with anything that depended on them (this is the same mechanism that drops +functional indexes on encrypted columns). **Re-run your grant script after +upgrading.** The schema-wide form EQL documents — +`GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3 TO app_role` — picks up both +the new name and the alias on its own. **With the rename made non-breaking by +the alias, this is the only part of the upgrade that needs action.** Two artefacts carry the new bundle: - A new upgrade edge, `20260814T0000_upgrade_eql_v3_3_0_5`, carrying the invariant `cipherstash:upgrade-eql-v3-bundle-3.0.5-v1`. Databases already running an earlier bundle re-install through this edge on the next - `prisma-next migrate`, exactly as they did for 3.0.2 and 3.0.4. + `prisma-next migration plan` followed by `prisma-next migrate`, exactly as + they did for 3.0.2 and 3.0.4. **`migrate` alone is not enough** — the seed + phase that copies a new migration package into your repo runs only from + `migration plan`, so without it the 3.0.5 directory never reaches disk and + `migrate` is a silent no-op that leaves the database on the older bundle. - The baseline install migration `20260601T0100_install_eql_v3_bundle`, whose baked bundle moves to 3.0.5 and which gains a fourth no-SQL carrier op for the new invariant. Fresh databases therefore land on 3.0.5 from the single @@ -23,11 +50,18 @@ Two artefacts carry the new bundle: **Action required.** The baseline's bytes — and so its `migrationHash` — have changed. If your project already has a `migrations/cipherstash/` directory generated against `@cipherstash/stack-prisma@1.0.0`, delete that directory and -re-run `prisma-next migration plan` (or `migrate`); the seed phase regenerates -it byte-identical to the shipped artefacts. Your database keeps its markers, so +re-run `prisma-next migration plan`; the seed phase regenerates it +byte-identical to the shipped artefacts. Your database keeps its markers, so already-applied invariants are not re-run — the only new work is the 3.0.5 upgrade edge. +If you skip the delete, nothing warns you: a vendored baseline is stale but +internally intact, so it passes every integrity check. On an existing database +the upgrade still applies correctly; on a **fresh** one, `db init` refuses with +`Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is +not allowed by policy.` — an error that names neither the directory nor the +remedy. See "Upgrading from 1.0.0" in the package README. + **Why the baseline was re-emitted rather than left frozen.** These artefacts are content-addressed and normally append-only: an EQL bump ships as a new upgrade directory and published directories are never rewritten. That rule cannot be diff --git a/.changeset/prisma-skill-upgrade-replan.md b/.changeset/prisma-skill-upgrade-replan.md new file mode 100644 index 000000000..19d93f919 --- /dev/null +++ b/.changeset/prisma-skill-upgrade-replan.md @@ -0,0 +1,16 @@ +--- +'stash': patch +--- + +`skills/stash-prisma` now documents the re-plan step that follows an +`@cipherstash/stack-prisma` upgrade: `rm -rf migrations/cipherstash && npx +prisma-next migration plan`, why only `migration plan` vendors new migration +packages, and the exact `db init` refusal a stale vendored directory produces on +a fresh database (`Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class +"data" which is not allowed by policy.`). + +The package README already carried this; the skill did not — and the skill is +what ships inside the `stash` tarball and gets copied into a user's +`.claude/skills/`, so an agent driving the upgrade hit the refusal with no route +out of it. `packages/stack-prisma/test/v3/stale-vendored-space.test.ts` now pins +both files to the planner's real message so they cannot drift apart again. diff --git a/.changeset/stack-prisma-upgrade-from-1-0-0.md b/.changeset/stack-prisma-upgrade-from-1-0-0.md new file mode 100644 index 000000000..311ae91a5 --- /dev/null +++ b/.changeset/stack-prisma-upgrade-from-1-0-0.md @@ -0,0 +1,16 @@ +--- +'@cipherstash/stack-prisma': patch +--- + +Document the 1.0.0 → 3.0.5 upgrade in the package README: why +`migrations/cipherstash/` must be deleted and regenerated, what each Prisma Next +command does if it is not, and the exact `db init` refusal +(`Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is +not allowed by policy.`) that a stale vendored directory produces on a fresh +database. + +The behaviour worth knowing regardless of version: only `prisma-next migration +plan` copies new migration packages into your repo. Running `migrate` or +`db init` after upgrading this package without planning first silently leaves +the database on the older EQL bundle — a stale vendored directory is internally +intact, so it passes every integrity check and nothing reports a problem. diff --git a/.github/actions/build-ffi-binding/action.yml b/.github/actions/build-ffi-binding/action.yml index ea5bc72e8..bee2c7228 100644 --- a/.github/actions/build-ffi-binding/action.yml +++ b/.github/actions/build-ffi-binding/action.yml @@ -54,13 +54,41 @@ runs: # package.json, and mise.toml pins the toolchain that compiles it. # Edit either and the Rust hash is unchanged, so the cache hit skips # the build step below and the job proceeds on a stale index.node. + # + # The last two are NOT in this package. `crates/protect-ffi/Cargo.toml` + # carries `eql-bindings = { path = "../../../eql/crates/eql-bindings" }` + # — an in-tree path dependency that compiles into `index.node` and into + # the wasm build below. A path dep has no registry checksum, so a + # source-only edit there moves NOTHING this key would otherwise hash: + # not `crates/**`, not either manifest, and not `Cargo.lock`, which + # records the crate by name and version and only moves when the version + # does. Every glob hashes identically, the restore hits, the build below + # is skipped, and every credentialed job runs a stale binding. (This is + # observed, not theoretical: the crate went 3.0.4 -> 4.0.0 -> 3.0.5 + # across three commits and neither key here changed by a byte.) + # + # `crates/**` rather than the one crate, deliberately. `eql-bindings` + # has no path deps of its own TODAY, so the narrower glob would be exact + # — and would silently stop being exact the moment it gains one on a + # sibling in that workspace, which is the same hole one level down. The + # cost of the wider glob is a spurious miss when an unrelated EQL crate + # changes; the cost of the narrower one is a stale binary. Guarded by + # `scripts/__tests__/ffi-binding-action.test.mjs`, which discovers the + # path deps from the manifest rather than trusting this comment. + # + # The EQL workspace root manifest comes with it: cargo reads it for the + # crate's workspace context, so a `.workspace = true` added to + # eql-bindings (three of its four siblings already inherit `[lints]` + # that way) would make it a compile input with no other trace. key: >- ffi-native-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('packages/protect-ffi/crates/**', 'packages/protect-ffi/Cargo.toml', 'packages/protect-ffi/Cargo.lock', 'packages/protect-ffi/package.json', - 'packages/protect-ffi/mise.toml') }} + 'packages/protect-ffi/mise.toml', + 'packages/eql/crates/**', + 'packages/eql/Cargo.toml') }} # Always, hit or miss: `lib/` is `tsc` over `src/`, which is seconds, and # it tracks a different input set than the cached binary. @@ -136,11 +164,20 @@ runs: # under src/ are the eql-v3-types declarations, which that tsconfig # never reads. ffi-binding-action.test.mjs walks the tsconfig's imports # and fails if this stops being the complete input set. + # + # `packages/eql/**` is here for the reason spelled out on the native key + # above, and it is NOT redundant with it: wasm-pack compiles the same + # `eql-bindings` path dependency for wasm32 into + # `protect_ffi_inline.js`, which is the bundle + # `@cipherstash/stack/wasm-inline` imports. Two keys, two archives, the + # same missing input. key: >- ffi-wasm-${{ runner.os }}-${{ hashFiles('packages/protect-ffi/crates/**', 'packages/protect-ffi/Cargo.toml', 'packages/protect-ffi/Cargo.lock', + 'packages/eql/crates/**', + 'packages/eql/Cargo.toml', 'packages/protect-ffi/dist/wasm/*.d.ts', 'packages/protect-ffi/src/errors.ts', 'packages/protect-ffi/package.json', diff --git a/.github/dependabot.yml b/.github/dependabot.yml index bd1c83c0d..a4bdb9370 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -62,7 +62,7 @@ updates: update-types: - version-update:semver-major - # ── Cargo (packages/protect-ffi — the only Rust in the repo) ──── + # ── Cargo (packages/protect-ffi — one of two Rust workspaces) ─── # Absorbing protect-ffi brought a 494-crate Cargo.lock in-tree. osv-scanner # already sees it — `--recursive ./` walks the tree and extracts every # lockfile it recognises — so known advisories were visible from day one, but diff --git a/.github/workflows/bench-eql.yml b/.github/workflows/bench-eql.yml index b49787ffa..eb9a1952b 100644 --- a/.github/workflows/bench-eql.yml +++ b/.github/workflows/bench-eql.yml @@ -17,17 +17,39 @@ on: branches: - main # Repo-root relative, so every entry gained the subtree prefix. Unprefixed, - # `src/**/*.sql` and `tests/sqlx/**/*` match nothing under this repository's - # root and the bench would simply stop running on pushes — silently, since - # a workflow that never triggers reports nothing at all. + # `src/**` and `tests/**` match nothing under this repository's root and the + # bench would simply stop running on pushes — silently, since a workflow + # that never triggers reports nothing at all. + # + # IDENTICAL to `test-eql.yml`'s list, modulo each file naming itself, and + # held that way by `scripts/__tests__/eql-workflow-filters.test.mjs`. The + # bench is a strict subset of that suite's inputs, so a bespoke narrower + # list here is possible and was what the port carried — and it had drifted + # three ways, each of them a change that alters what the bench measures + # while never starting it: + # + # * `src/**/*.sql` missed `src/v3/version.template`, which `tasks/build.sh` + # names in its own `#MISE sources` and `sed`s into `version.sql`. + # * `tests/sqlx/**/*` missed `tests/docker-compose.yml` — the file + # `postgres:up` actually runs, one level above the glob. + # * `mise.toml` was absent entirely, and it defines every `mise run` task + # below plus the toolchain that compiles them. + # + # Two lists that answer the same question are worth more kept equal than + # kept minimal: the cost of over-triggering is one nightly-budget bench run, + # and the cost of under-triggering is a regression that lands and is + # attributed to whatever merges next. paths: - ".github/workflows/bench-eql.yml" - - "packages/eql/src/**/*.sql" - - "packages/eql/tests/sqlx/**/*" - - "packages/eql/tasks/**/*" + - ".github/actions/require-cs-secrets/**" + - "packages/eql/src/**" + - "packages/eql/tests/**" + - "packages/eql/tasks/**" - "packages/eql/crates/**" + - "packages/eql/packages/**" - "packages/eql/Cargo.toml" - "packages/eql/Cargo.lock" + - "packages/eql/mise.toml" schedule: # 02:00 UTC daily @@ -113,7 +135,17 @@ jobs: CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }} CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }} CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }} + # `set -euo pipefail` because the workflow-wide `shell: bash {0}` drops + # GitHub's implicit `-eo pipefail`: without it a failing `rustup + # component add` is discarded and only `test:bench` decides the step, + # which then fails several minutes later for a reason that reads as a + # bench regression. Enforced by + # `scripts/__tests__/workflow-run-fail-fast.test.mjs`. + # + # Assignment on its own rather than `export x=$(…)`: errexit ignores + # the substitution's status when the line starts with a command word. run: | - export active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1) - rustup component add --toolchain ${active_rust_toolchain} rustfmt clippy + set -euo pipefail + active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1) + rustup component add --toolchain "${active_rust_toolchain}" rustfmt clippy mise run --output prefix test:bench --postgres ${POSTGRES_VERSION} diff --git a/.github/workflows/integration-drizzle.yml b/.github/workflows/integration-drizzle.yml index 107b2b7bd..cc4658036 100644 --- a/.github/workflows/integration-drizzle.yml +++ b/.github/workflows/integration-drizzle.yml @@ -86,6 +86,16 @@ on: # Pinned by scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs. - 'packages/protect-ffi/tsconfig.wasm-errors.json' - 'packages/protect-ffi/scripts/inline-wasm.mjs' + # Out of that package, and compiled into the same two artifacts: the + # cdylib crate carries + # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the + # EQL wire types are linked into `index.node` and into + # `protect_ffi_inline.js`. Both cache keys in + # `.github/actions/build-ffi-binding` hash them, so an edit here misses + # that cache and rebuilds the bundle the `integration/wasm/**` suites + # load. Same argument as the two entries above, same guard. + - 'packages/eql/crates/**' + - 'packages/eql/Cargo.toml' pull_request: branches: ['**'] # Repeated verbatim: GitHub Actions does not support YAML anchors/aliases. @@ -160,6 +170,16 @@ on: # Pinned by scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs. - 'packages/protect-ffi/tsconfig.wasm-errors.json' - 'packages/protect-ffi/scripts/inline-wasm.mjs' + # Out of that package, and compiled into the same two artifacts: the + # cdylib crate carries + # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the + # EQL wire types are linked into `index.node` and into + # `protect_ffi_inline.js`. Both cache keys in + # `.github/actions/build-ffi-binding` hash them, so an edit here misses + # that cache and rebuilds the bundle the `integration/wasm/**` suites + # load. Same argument as the two entries above, same guard. + - 'packages/eql/crates/**' + - 'packages/eql/Cargo.toml' jobs: integration: diff --git a/.github/workflows/integration-protect-ffi.yml b/.github/workflows/integration-protect-ffi.yml index fcd48f90b..f95d4c743 100644 --- a/.github/workflows/integration-protect-ffi.yml +++ b/.github/workflows/integration-protect-ffi.yml @@ -61,6 +61,16 @@ on: # toolchain pins, and the PG* connection env. - 'packages/protect-ffi/package.json' - 'packages/protect-ffi/mise.toml' + # Out of this package, and a real compile input: the cdylib crate carries + # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the + # EQL wire types are linked into `index.node` AND into the wasm32 build + # this suite's `wasm-round-trip` test loads. Both cache keys in + # `.github/actions/build-ffi-binding` hash these, so an edit misses the + # cache and rebuilds the binding — without these entries it would be + # rebuilt and no suite that loads it would start. Pinned by + # scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs. + - 'packages/eql/crates/**' + - 'packages/eql/Cargo.toml' - '.github/workflows/integration-protect-ffi.yml' - '.github/actions/build-ffi-binding/**' - '.github/actions/require-cs-secrets/**' @@ -79,6 +89,16 @@ on: - 'packages/protect-ffi/tsconfig.wasm-errors.json' - 'packages/protect-ffi/package.json' - 'packages/protect-ffi/mise.toml' + # Out of this package, and a real compile input: the cdylib crate carries + # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the + # EQL wire types are linked into `index.node` AND into the wasm32 build + # this suite's `wasm-round-trip` test loads. Both cache keys in + # `.github/actions/build-ffi-binding` hash these, so an edit misses the + # cache and rebuilds the binding — without these entries it would be + # rebuilt and no suite that loads it would start. Pinned by + # scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs. + - 'packages/eql/crates/**' + - 'packages/eql/Cargo.toml' - '.github/workflows/integration-protect-ffi.yml' - '.github/actions/build-ffi-binding/**' - '.github/actions/require-cs-secrets/**' diff --git a/.github/workflows/macro-expand-eql.yml b/.github/workflows/macro-expand-eql.yml index 5496b5620..76ee3391d 100644 --- a/.github/workflows/macro-expand-eql.yml +++ b/.github/workflows/macro-expand-eql.yml @@ -80,13 +80,31 @@ jobs: # an unpinned version could drift the snapshot even with a frozen macro + # nightly. The snapshot then only moves when the macro moves. - name: Install pinned nightly toolchain + # `set -eu`, deliberately WITHOUT `pipefail`: the workflow-wide + # `shell: bash {0}` drops GitHub's implicit `-eo pipefail`, so errexit + # has to be asked for (see + # `scripts/__tests__/workflow-run-fail-fast.test.mjs`) — but `head -1` + # closes the pipe as soon as it has its line, so under `pipefail` a + # grep that still had output to write reports 141 and fails the step on + # a successful match. Same SIGPIPE hazard as + # `scripts/__tests__/workflow-grep-q-pipelines.test.mjs`. The `test -n` + # below already covers the case this pipeline can genuinely fail in. run: | + set -eu NIGHTLY=$(grep -oE 'nightly-[0-9]{4}-[0-9]{2}-[0-9]{2}' mise.toml | head -1) test -n "$NIGHTLY" || { echo "could not find pinned nightly in mise.toml"; exit 1; } rustup toolchain install "$NIGHTLY" --profile minimal --component rustfmt - name: Regenerate and verify the matrix expansion snapshots + # `set -euo pipefail` is load-bearing here, more than anywhere else in + # this file. Without it the workflow-wide `shell: bash {0}` discards the + # regeneration's exit code and the `git diff` below decides the step — + # so when `test:matrix:expand` BREAKS, the snapshots are untouched, the + # diff is clean, and this job reports success having verified that a + # build which never ran produced no drift. Enforced by + # `scripts/__tests__/workflow-run-fail-fast.test.mjs`. run: | + set -euo pipefail mise run test:matrix:expand git diff --exit-code -- \ tests/sqlx/snapshots/integer_expanded.rs \ diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 3c4245dcc..6c58a4491 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -273,6 +273,67 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # REQUIRED BY `version:` BELOW, and nothing in this file says so without + # this comment — which is why there is also a test. `pnpm run version` is + # `changeset version && node scripts/sync-lockstep-versions.mjs`, and that + # script ends in `execFileSync('mise', ['run', + # 'release:prepare_bindings_assets', …])`, which reaches + # `packages/eql/tasks/build.sh` and two `cargo run -p eql-codegen` calls. + # mise is NOT preinstalled on GitHub's ubuntu images, so without this step + # the hook dies with ENOENT — AFTER `changeset version` has already + # rewritten every manifest and changelog, in a job holding + # `contents: write`. Asserted by + # scripts/__tests__/workflow-mise-setup.test.mjs. + # + # It only fires on the branch where `.changeset/` is non-empty (the + # Version Packages branch), which is why a publish rehearsal never + # exercised it. + # + # `working_directory: packages/eql` for the reason test-eql.yml records at + # length: mise reads config from the current directory and its PARENTS, so + # an action running at the repo root never sees `packages/eql/mise.toml`. + # It would install nothing and leave the config untrusted, and the first + # `mise run` fails with "Config files … are not trusted" — which reads as + # a toolchain problem rather than a path one. That file is also where the + # Rust toolchain comes from (`[tools] rust`), so this step is the cargo + # setup as well; there is deliberately no second one. + # + # `cache: false` IS NOT THE DEFAULT — jdx/mise-action caches by default, + # and scripts/lint-no-workflow-caching.mjs forbids a GitHub Actions cache + # restore anywhere an artifact gets published. A poisoned entry here would + # execute in the job that holds the npm publishing credential. + # + # `add_shims_to_path: false` IS LOAD-BEARING, and it is the input a + # copy-paste from test-eql.yml would not carry. `packages/eql/mise.toml` + # pins `node = "22"` under `[tools]`, and mise's shim directory is + # PREPENDED to PATH for every later step — so with the default `true`, + # mise's own Node would shadow the one `actions/setup-node` installed, and + # `changeset publish` would shell out to that Node's bundled npm 10.x + # instead of the `npm@^11.5.1` installed above. OIDC trusted publishing + # requires >= 11.5.1 and fails with E404 below it, which is the exact + # failure the two comments above this step exist to prevent. `mise run` + # resolves its own toolchain internally, so nothing here needs the shims. + # + # `env: false` for a smaller version of the same argument: the default + # exports that file's `[env]` block — `DATABASE_URL`, `POSTGRES_PASSWORD` + # and friends, all pointed at a Postgres this job does not have — into + # GITHUB_ENV for every subsequent step. + # + # SHA-pinned, matching .github/actions/build-ffi-binding/action.yml: + # mise-action executes third-party code in the job that publishes, so a + # mutable `@v4` would let that code change with no commit here. The pin is + # the same v4 commit test-eql.yml uses. Dependabot moves the pin and the + # trailing comment together (.github/dependabot.yml covers github-actions). + - name: Install mise (the lockstep version hook shells out to it) + uses: jdx/mise-action@1648a7812b9aeae629881980618f079932869151 # v4 + with: + version: 2026.4.0 + install: true + cache: false + working_directory: packages/eql + add_shims_to_path: false + env: false + - name: Publish to npm id: changesets uses: changesets/action@v1.9.0 diff --git a/.github/workflows/test-eql.yml b/.github/workflows/test-eql.yml index b6cdf71db..cf52c8de5 100644 --- a/.github/workflows/test-eql.yml +++ b/.github/workflows/test-eql.yml @@ -30,19 +30,63 @@ name: "Test EQL" # — it yields the empty string, and the suite would fail at client construction # in every shard instead of saying what was missing. # -# NB: NO path filter at on: level. A workflow skipped by a path/branch filter +# NB: NO path filter on `pull_request`. A workflow skipped by a path filter # leaves its required checks stuck Pending and blocks merge. Relevance is -# computed by the `changes` job and applied per-job via `if:` instead. +# computed by the `changes` job and applied per-job via `if:` instead. `push` +# carries one because nothing waits on a push run, so a skipped one costs +# nothing — and the two lists are kept identical by +# `scripts/__tests__/eql-workflow-filters.test.mjs`. # -# NB: NO `push:` trigger, and that is not the same as "runs rarely". This runs -# on `pull_request` — every PR, unfiltered, with relevance applied per job — and -# on `merge_group`. Under a required merge queue, push-to-main validation is -# redundant: the queue already validated the exact merge commit, and branch -# protection blocks direct pushes. (Resolves the design's ambiguous "light jobs -# only on push:main" sanity net by dropping the trigger entirely.) +# WHY `push` AND `schedule` EXIST. The port arrived with `merge_group` as the +# ONLY route to the full PG 14-17 matrix, and with no `push:` at all, +# justified by "under a required merge queue, push-to-main validation is +# redundant". Every clause of that premise is false in this repository, checked +# against the live API: there is no merge queue on `main` +# (`mergeQueue(branch:"main")` -> null), `main` is not protected +# (`branches/main/protection` -> 404), and the active ruleset carries no +# `required_status_checks` rule, so `ci-required` is required by nothing. +# `merge_group` is an event this repo never emits — so PG 14, 15 and 16 were +# tested NEVER, and nothing EQL-related ran after a merge. Both failures are +# invisible, because an event that is never delivered produces no runs to +# notice the absence of. Pinned by +# `scripts/__tests__/eql-matrix-triggers.test.mjs`, which refuses to count +# `merge_group` or `workflow_dispatch` as reachable. +# +# WHY THIS SHAPE, and not "full matrix on every push". The expensive axis is +# the fan-out, not the trigger: PG 14-17 x 2 shards is roughly double the +# runner-minutes of the PR lane. So the cost is bounded by the FILTER rather +# than by running a smaller matrix — a `push` run only starts when the merge +# actually touched EQL, which is a small fraction of merges to `main`, and when +# it does start the extra PG versions are the entire reason to run it at all. +# Attributing a PG14 break to the merge that caused it is worth much more than +# finding it detached at 04:00 the next morning. `schedule` then backstops the +# case the filter cannot see (a dependency or toolchain moving underneath a +# tree nobody touched), and both use the same full matrix. +# +# `pull_request` keeps the fast lane — PG17 x 4 shards, every PR, unfiltered, +# with relevance applied per job — because latency is what matters there and +# PG17 catches all but version-specific breakage. on: pull_request: {} - merge_group: {} # required pre-merge gate; runs the full matrix + push: + branches: [main] + # Identical to the `relevant:` filter in the `changes` job below. GitHub + # Actions has no YAML anchors, so the list is written twice; the guard named + # above fails a one-sided edit. + paths: + - ".github/workflows/test-eql.yml" + - ".github/actions/require-cs-secrets/**" + - "packages/eql/src/**" + - "packages/eql/tests/**" + - "packages/eql/tasks/**" + - "packages/eql/crates/**" + - "packages/eql/packages/**" + - "packages/eql/Cargo.toml" + - "packages/eql/Cargo.lock" + - "packages/eql/mise.toml" + schedule: + - cron: "0 4 * * *" # 04:00 UTC daily; full matrix, off the merge path + merge_group: {} # inert today (no queue); kept so enabling one works workflow_dispatch: {} # manual runs use the PR shape (PG17 x 4 shards) env: @@ -88,7 +132,10 @@ jobs: persist-credentials: false # Diff ONLY on pull_request, where a base ref is well-defined. On - # merge_group/workflow_dispatch the base ref is absent and the filter errors/empties. + # push/schedule/merge_group/workflow_dispatch there is no base ref to + # diff against and the filter errors or empties — so those events take the + # hardcoded default in the step below instead. `push` does not need it: + # its `on:`-level `paths:` has already decided whether the run happens. - id: f if: github.event_name == 'pull_request' uses: dorny/paths-filter@d1c1ffe0248fe513906c8e24db8ea791d46f8590 # v3 @@ -99,32 +146,53 @@ jobs: # `packages/stack/src/**` and friends instead — firing the whole # matrix on changes that cannot affect EQL, and (worse) NOT firing on # EQL's own `src/`, since nothing at the repo root is called that. + # + # Identical to the `push` `paths:` list at the top of this file — the + # same question asked of two mechanisms GitHub gives no way to share. + # `scripts/__tests__/eql-workflow-filters.test.mjs` compares them, and + # also fails any entry here that matches no tracked file (a dead + # `packages/eql/sql/**` sat in this list from the port: there is no + # such directory, so it narrowed the filter by exactly nothing while + # reading as coverage). filters: | relevant: - ".github/workflows/test-eql.yml" + - ".github/actions/require-cs-secrets/**" - "packages/eql/src/**" - - "packages/eql/sql/**" - "packages/eql/tests/**" - "packages/eql/tasks/**" - "packages/eql/crates/**" + - "packages/eql/packages/**" - "packages/eql/Cargo.toml" - "packages/eql/Cargo.lock" - "packages/eql/mise.toml" # Explicit default (not `|| 'true'`, which trips GitHub's inconsistent - # treatment of the string 'false'). merge_group/workflow_dispatch never - # read this value — their downstream `if:` branch ignores `relevant` — but - # default true is the safe value regardless. + # treatment of the string 'false'). push/schedule/merge_group/dispatch + # never run the filter above — it needs a base ref that only a pull + # request has — so they take the default, and `push` is already narrowed + # by its own `on:`-level `paths:`. + # + # The event arrives through `env:`, not through a `${{ }}` interpolated + # into the body. That is what lets + # `scripts/__tests__/eql-matrix-triggers.test.mjs` EXECUTE this script + # once per event and read back what it wrote, rather than reimplementing + # the branch and agreeing with a rewritten one by luck. - id: r + env: + EVENT_NAME: ${{ github.event_name }} + FILTER_RELEVANT: ${{ steps.f.outputs.relevant }} run: | - if [ "${{ github.event_name }}" = "pull_request" ]; then - echo "relevant=${{ steps.f.outputs.relevant }}" >> "$GITHUB_OUTPUT" + set -euo pipefail + if [ "$EVENT_NAME" = "pull_request" ]; then + echo "relevant=$FILTER_RELEVANT" >> "$GITHUB_OUTPUT" else echo "relevant=true" >> "$GITHUB_OUTPUT" fi # Pure bash; no checkout/toolchain. Derives the PG-version + shard fan-out - # from the event: PR -> PG17 x 4 shards; merge queue -> PG 14-17 x 2 shards. + # from the event: PR and manual dispatch -> PG17 x 4 shards (latency lane); + # everything else -> PG 14-17 x 2 shards (coverage lane). setup: name: "Compute matrix" runs-on: blacksmith-16vcpu-ubuntu-2204 @@ -141,33 +209,61 @@ jobs: shard-total: ${{ steps.cfg.outputs.shard_total }} shards: ${{ steps.cfg.outputs.shards }} steps: + # Written as an exclusion, and that direction is the point: the FULL + # matrix is the default, so a trigger added later lands in the coverage + # lane rather than in the fast one. The version of this that enumerated + # `merge_group` as the only full-matrix event is why PG 14-16 went + # untested for the life of the port — an allowlist fails shut on the case + # nobody enumerated, and here "shut" meant three Postgres versions. + # + # The event arrives through `env:` rather than an interpolated `${{ }}` + # so `scripts/__tests__/eql-matrix-triggers.test.mjs` can run this script + # against each event and read the real fan-out back out of + # `$GITHUB_OUTPUT`. - id: cfg + env: + EVENT_NAME: ${{ github.event_name }} run: | - if [ "${{ github.event_name }}" = "merge_group" ]; then - echo 'pg=[14,15,16,17]' >> "$GITHUB_OUTPUT" - echo 'shard_total=2' >> "$GITHUB_OUTPUT" - echo 'shards=[1,2]' >> "$GITHUB_OUTPUT" - else - echo 'pg=[17]' >> "$GITHUB_OUTPUT" - echo 'shard_total=4' >> "$GITHUB_OUTPUT" - echo 'shards=[1,2,3,4]' >> "$GITHUB_OUTPUT" - fi - - # Compile the test binaries ONCE. Runs in the queue and on workflow_dispatch - # always, and on PRs only when relevant files changed (docs-only PRs never pay - # the ~4-min compile). + set -euo pipefail + case "$EVENT_NAME" in + pull_request|workflow_dispatch) + # Latency lane: PG17 only, split four ways. + echo 'pg=[17]' >> "$GITHUB_OUTPUT" + echo 'shard_total=4' >> "$GITHUB_OUTPUT" + echo 'shards=[1,2,3,4]' >> "$GITHUB_OUTPUT" + ;; + *) + # Coverage lane: every version tests/docker-compose.yml ships a + # container for. Kept in step by the guard named above. + echo 'pg=[14,15,16,17]' >> "$GITHUB_OUTPUT" + echo 'shard_total=2' >> "$GITHUB_OUTPUT" + echo 'shards=[1,2]' >> "$GITHUB_OUTPUT" + ;; + esac + + # Compile the test binaries ONCE. Runs on every non-PR event, and on PRs only + # when relevant files changed (docs-only PRs never pay the ~4-min compile). build-archive: name: "Build test archive" needs: [changes] # This repo is PUBLIC and accepts fork PRs (the approval policy only gates # first-time contributors). build-archive is the sole holder of the CS_* # credentials below, so it must never run on a fork PR. The trailing clause - # restricts it to push / workflow_dispatch / same-repo branch PRs; the - # downstream test/validate shards `needs:` it, so they skip on fork PRs too. + # is the only thing that skips it: a fork pull request. Every other event — + # push, schedule, merge_group, dispatch, and a same-repo branch PR — runs; + # the downstream test/validate shards `needs:` it, so they skip on fork PRs + # too. + # + # Both clauses are written as exclusions rather than as a list of admitted + # events. An allowlist fails SHUT on the event nobody enumerated, and the + # `push`/`schedule` triggers added above would have skipped every job in + # this file while the run still reported success. Pinned by + # `scripts/__tests__/eql-matrix-triggers.test.mjs`; the fork clause itself + # is compared verbatim across all eight copies in the repo by + # `scripts/__tests__/workflow-dispatch-job-conditions.test.mjs`. if: >- - (github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')) + (github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true') && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) runs-on: blacksmith-16vcpu-ubuntu-2204 @@ -248,10 +344,10 @@ jobs: test: name: "Shard PG${{ matrix.postgres-version }} ${{ matrix.shard }}/${{ needs.setup.outputs.shard-total }}" needs: [changes, setup, build-archive] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 strategy: fail-fast: false @@ -308,10 +404,10 @@ jobs: validate: name: "Validate (Postgres ${{ matrix.postgres-version }})" needs: [changes, setup] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 strategy: fail-fast: false @@ -350,17 +446,25 @@ jobs: mise run docs:validate:documented-sql - name: Clean-DB v3 install smoke (Postgres ${{ matrix.postgres-version }}) + # `set -euo pipefail` for the reason spelled out on `matrix-coverage`'s + # inventory step and enforced by + # `scripts/__tests__/workflow-run-fail-fast.test.mjs`: the workflow-wide + # `shell: bash {0}` drops GitHub's implicit `-eo pipefail`, so without + # it a failing BUILD on the first line is discarded and the smoke test + # on the second decides the step — i.e. the install smoke would pass by + # installing the previous build. run: | + set -euo pipefail mise run clean && mise run build mise run test:clean_install_v3 schema: name: "JSON Schema validation" needs: [changes] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 @@ -384,10 +488,10 @@ jobs: rust-crates: name: "Rust workspace crates" needs: [changes] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 @@ -409,8 +513,13 @@ jobs: # standalone `test:lint` step that the removed per-version test job ran. - name: Compile, lint and test the Rust workspace crates run: | - export active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1) - rustup component add --toolchain ${active_rust_toolchain} rustfmt clippy + set -euo pipefail + # Assignment on its own, not `export x=$(…)`: errexit ignores the + # substitution's status when the line starts with a command word, so + # the `export` form would swallow a failing `rustup show` even under + # `set -e`. + active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1) + rustup component add --toolchain "${active_rust_toolchain}" rustfmt clippy mise run test:crates # Freshness gate for the eql-types codegen output: regenerate the @@ -433,10 +542,10 @@ jobs: codegen: name: "Encrypted-domain codegen" needs: [changes] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 @@ -463,10 +572,10 @@ jobs: self-contained-v3: name: "eql_v3 self-containment" needs: [changes] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 @@ -497,10 +606,10 @@ jobs: matrix-coverage: name: "Matrix coverage inventory" needs: [changes] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 @@ -537,10 +646,10 @@ jobs: splinter: name: "Supabase splinter" needs: [changes] + # Exclusion, not an allowlist — see the note on `build-archive`. if: >- - github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true') + github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true' runs-on: blacksmith-16vcpu-ubuntu-2204 env: POSTGRES_VERSION: "17" @@ -559,11 +668,18 @@ jobs: mise run postgres:up postgres-${POSTGRES_VERSION} --extra-args "--detach --wait" - name: Build and install EQL run: | + set -euo pipefail mise run clean && mise run --output prefix --force build - cat release/cipherstash-encrypt.sql \ - | docker exec -i postgres-${POSTGRES_VERSION} \ - psql -v ON_ERROR_STOP=1 \ - postgresql://cipherstash:password@localhost/cipherstash -f- + # Redirected, not piped. `psql -v ON_ERROR_STOP=1` exits at the first + # SQL error, which under `pipefail` leaves a `cat` writing into a + # closed pipe and reports the step as 141 — the SIGPIPE hazard + # `scripts/__tests__/workflow-grep-q-pipelines.test.mjs` documents. + # The redirect is the same bytes with no writer to signal, so the + # step reports psql's own status and says which statement failed. + docker exec -i postgres-${POSTGRES_VERSION} \ + psql -v ON_ERROR_STOP=1 \ + postgresql://cipherstash:password@localhost/cipherstash -f- \ + < release/cipherstash-encrypt.sql - name: Run splinter run: | mise run --output prefix test:splinter --postgres ${POSTGRES_VERSION} @@ -672,10 +788,11 @@ jobs: e2e: name: "e2e property suite (fresh encryption)" needs: [changes, setup] + # Exclusion, not an allowlist — see the note on `build-archive`, which + # carries the same two clauses for the same two reasons. if: >- - (github.event_name == 'merge_group' - || github.event_name == 'workflow_dispatch' - || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')) + (github.event_name != 'pull_request' + || needs.changes.outputs.relevant == 'true') && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) runs-on: blacksmith-16vcpu-ubuntu-2204 @@ -739,6 +856,7 @@ jobs: steps: - name: Assert all required jobs passed or were skipped run: | + set -euo pipefail results='${{ join(needs.*.result, ' ') }}' echo "needed results: $results" for r in $results; do diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index fcc766b6b..8db055cc7 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -271,6 +271,30 @@ jobs: - name: Lint — no protect-ffi changeset before the publishing cutover run: pnpm run lint:ffi-changeset + # THE SAME GATE release.yml RUNS, one merge earlier. + # + # `changeset publish` publishes every public workspace package whose + # version is absent from npm — with no dependency ordering, and a failed + # publish returns a result rather than throwing, so it does not stop the + # siblings that depend on it. A merge can therefore ARM a release that + # cannot succeed: `@cipherstash/eql` was hand-bumped to 3.0.5 while npm's + # newest is 3.0.4 and its trusted publisher still names + # cipherstash/encrypt-query-language, and `packages/cli` and + # `packages/stack-prisma` carry it in RUNTIME dependencies, so both would + # pack `^3.0.5` — a range no published version satisfies. + # + # The gate in release.yml blocks the publish, which is the load-bearing + # half. This step is the half that says so BEFORE the merge rather than + # after it, which is the difference between a red pull request and a red + # main. Same script, same verdict, no second copy to drift. + # + # It talks to the registry, in a job that already installs the whole + # workspace from it — so this adds a class of dependency the job does not + # already have, only a few more requests. A lookup that fails for any + # reason other than a 404 throws rather than being read as "published". + - name: Lint — this tree can be published, and installed + run: pnpm run release:gate + - name: Test — lint script self-tests run: pnpm run test:scripts diff --git a/AGENTS.md b/AGENTS.md index da9f95f20..33645256b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -83,6 +83,7 @@ If these variables are missing, tests that require live encryption will fail or - `packages/utils`: Shared config (`utils/config`) and logger (`utils/logger`) - `packages/bench`: Performance / index-engagement benchmarks (private, not published) - `packages/protect-ffi`: Native FFI bindings to the CipherStash Client SDK (`@cipherstash/protect-ffi`) — the Rust core that `packages/stack` encrypts and decrypts through, absorbed from `cipherstash/protectjs-ffi`. Contains a **nested Cargo workspace** (`crates/`) and six per-platform binary packages under `platforms/*`, each published as `@cipherstash/protect-ffi-` and linked here via `workspace:*`. See the "Working on protect-ffi" notes below before touching it — its default `test` and `build` are deliberately Rust-free. +- `packages/eql`: The Encrypt Query Language subtree — the SQL bundle that stores and queries encrypted payloads — absorbed from `cipherstash/encrypt-query-language`. **The directory is the subtree root, not the package.** It was imported at a *verbatim prefix* so its repo-root-relative paths (mise tasks, `Doxyfile`, `sync-generated.mjs`) keep resolving, which puts the npm package `@cipherstash/eql` two levels down at `packages/eql/packages/eql` — the same shape as `packages/protect-ffi/platforms/*`, and enrolled the same way, by an explicit `packages/eql/packages/*` glob in `pnpm-workspace.yaml`. The subtree root deliberately carries no `package.json`. Also contains a **nested Cargo workspace** at `packages/eql/crates/` (`eql-bindings`, published in lockstep with the npm package, plus `eql-domains` / `eql-codegen` / `eql-tests-macros`, which are not), a SQLx test crate at `packages/eql/tests/sqlx`, an ~900-line `mise.toml` task surface, its own `AGENTS.md`, and `docs/`. See the "Working on EQL" notes below before touching it. - `e2e/*`: Cross-package end-to-end tests (package managers, supply chain, Prisma example README) - `examples/*`: Working apps (basic, prisma, supabase-worker) - `docs/plans/*`: Internal design plans. User-facing documentation lives at https://cipherstash.com/docs (not in this repo). @@ -90,11 +91,12 @@ If these variables are missing, tests that require live encryption will fail or ## Working on protect-ffi -`packages/protect-ffi` is the only Rust in this repo, and its scripts are split -so that stays true for everyone else. +`packages/protect-ffi` carries one of this repo's two Cargo workspaces (the +other is `packages/eql/crates`), and its scripts are split so a Rust toolchain +stays optional for everyone else. - **The default `test` and `build` never invoke cargo.** Root `pnpm test` runs - `turbo test --filter './packages/*'`, which reaches this package — so a cargo + `turbo test --filter './packages/**'`, which reaches this package — so a cargo process on that path is a Rust toolchain on every contributor's machine. `test` is the JS chain; `build` is `tsc`. - **CI does build the binding, in the jobs that need it.** That is the limit of @@ -214,6 +216,131 @@ EQL versions installed** in the database. what stops it going quiet again, and it deliberately scans only the repo-root workflow directory. +## Working on EQL + +`packages/eql` is a subtree import, not a package directory, and almost +everything surprising about it follows from that. Its own `AGENTS.md` +(`packages/eql/AGENTS.md`) covers EQL-internal work — SQL authoring, the codegen +pipeline, documentation standards. The notes below cover the *seams* with this +monorepo, which is where the silent failures are. + +- **The package is at `packages/eql/packages/eql`, two levels down.** The + subtree root has no `package.json` by design, so a tool that globs one level + under `packages/` selects the root — a directory with no manifest and no + scripts — and not the package. That is why root `pnpm test` is + `turbo test --filter './packages/**'` and not `'./packages/*'`: under the + one-level filter the task graph contained `@cipherstash/eql#build` (pulled in + transitively by its consumers) and **no `#test` at all**, so its Vitest suite + ran nowhere while CI stayed green. `build` can stay one-level because + consumers pull it through `^build`. Anything else that walks `packages/*` needs + the same treatment — `scripts/lint-typecheck-scope.mjs` already carries the + two nested roots explicitly. +- **Anything invoking a mise task must run with `working_directory: + packages/eql`.** `packages/eql/mise.toml` is ~900 lines and its + `[task_config].includes` pulls in `tasks/`, `tasks/postgres.toml` and + `tasks/fixtures.toml`; task bodies address `tasks/…`, `release/…` and + `tests/sqlx/…` relative to the subtree root. mise reads config from the + current directory and its parents, so invoking from the repo root finds no EQL + config and fails with a *trust* error that reads like a broken toolchain + rather than a wrong directory. `[env]` also pins `EQL_ROOT = {{config_root}}`, + because two task scripts use `git rev-parse --show-toplevel`, which after the + import returns the **monorepo** root — and one of them, + `tasks/test/doc-anchors.sh`, fails silently when that is wrong. +- **`packages/eql/.github/` is a dead deposit.** GitHub reads workflows from the + repo root and nowhere else, so the eleven files there run on nothing. Seven + are workflows — four publish something (`release.yml`, `release-plz.yml`, + `release-postgres-eql-image.yml`, `rebuild-docs.yml`) and three exist only to + serve them (two `workflow_call` reusables and `lint-release.yml`) — alongside + a `workflows/README.md`, the release-notes config, and two + repository-settings files. `scripts/__tests__/eql-suite-ci.test.mjs` holds + them as a **shrinking allowlist** (`UNPORTED_DEPOSIT`), asserted by equality so + it fails in both directions: porting a workflow means deleting it from the + deposit *and* from the list in the same commit, and dropping a new file in + there without listing it fails too. The same test asserts that the three SQLx + suite tasks are invoked by name from a root workflow, that every + `dorny/paths-filter` path is scoped to `packages/eql/`, and that every mise + task shelling out to cargo is either reachable from a root workflow or + exempted with a written reason. It is the guard against the failure this + absorption keeps rediscovering: a check that arrives as a file and executes on + no event reads exactly like a check that passes. +- **One version, five artefacts.** `@cipherstash/eql` (npm), the `eql-bindings` + crate, the SQL bundle, the docs and the `postgres-eql` image all ship at a + single version V. The npm package's `version` is the source of truth + (`changeset version` owns it) and `scripts/sync-lockstep-versions.mjs` + propagates it to the crate and, via `mise run + release:prepare_bindings_assets`, to the stamped SQL and release manifests. It + runs from the root `version` script — Changesets only invokes the *root* one, + which is why the script lives at the repo root and derives the subtree path + itself. **`mise run build --version X` does not treat `--version` as a + cache-key input**: it is absent from `tasks/build.sh`'s `#MISE sources`, so on + unchanged SQL and Rust it is a cache hit that re-serves whatever version the + previous build stamped. `tasks/release/prepare-bindings-assets.sh` passes + `--force` for exactly that reason and then greps the stamp back out of the + SQL before writing a manifest over it — read its comment before touching that + path. Without both, the bundle ships stamped one version under a manifest, + crate and npm package claiming another, and every digest still verifies. +- **`eql-bindings` resolves by path from `packages/protect-ffi`, never from + crates.io**, and `scripts/lint-no-eql-registry-pins.mjs` (`pnpm run + lint:eql-pins`) is what keeps it that way. The two halves of EQL are the Rust + that EMITS a payload and the SQL that STORES and queries one; a registry pin + lets them drift apart silently — it compiles, it passes CI, and it fails in a + database. The linter reads every `Cargo.toml` and `package.json` plus + `pnpm-workspace.yaml` (pnpm resolves `overrides` and `catalogs` from there, + and a top-level npm-format `overrides` block in a `package.json` is silently + ignored, so it is the one place a workspace-wide pin can be written and take + effect). It exits **2**, not 0, when its own configuration has gone stale — + a source it could not read, a declaration it expected and no longer sees, or + an exemption excusing nothing. There is one exemption today + (`packages/protect-ffi/integration-tests`, which installs with `npm ci` and + cannot take a `workspace:` specifier); adding another means writing the reason + down. +- **Two SQLx test constants are keyed to this repo's CI workspace.** SteVec + selectors are MACs over (column context, JSONPath) under a *workspace keyset*, + so `SELECTOR` in `tests/sqlx/src/fixtures/v3_doc_integer.rs` and `SEL_HELLO_OP` + in `tests/sqlx/src/fixtures/v3_ste_vec.rs` changed value — with no change to + Rust, SQL or fixture logic — the moment CI moved to this repo's + `CS_WORKSPACE_CRN` (`9467cc5d`, `da141339`). Each has a drift guard that + prints the candidate selectors and their discriminators rather than inferring + a replacement, because guessing wrong re-pins to the wrong leaf silently — + which had already happened once, `SEL_HELLO_OP` naming `$.number` while + claiming `$.hello` and surviving because an equality-only assertion cannot + separate them. **If you run the suite against your own CipherStash workspace + the guards will fire: do not commit your local value.** Rotating + `CS_WORKSPACE_CRN` re-pins both. `tests/sqlx/src/selectors.rs` holds five more + workspace-keyed constants with no consumers and no guard — delete or guard + them before using any of them. +- **Publishing has not moved yet.** npm trusted publishing for `@cipherstash/eql` + still names `cipherstash/encrypt-query-language` — the SLSA provenance on + `@cipherstash/eql@3.0.4` records that repository and + `.github/workflows/release.yml` — and the package's own `repository` / `bugs` + fields still point there, as do the `eql-bindings` crate's. Repointing all of + it is the Phase-5 cutover, together with the nine parked workflows above. + This is protect-ffi's situation with one difference: the guard is not a + changeset lint but `scripts/release-gate.mjs`, and it is the stronger of the + two. Its `FROZEN_PUBLISHERS` map lists every package that lives here but is + published from another repository, and the gate **exits non-zero** — failing + the `gate` job, which skips `release` entirely — if such a package's committed + version is missing from npm, or if any published package carries a runtime + `workspace:` range that only that package could satisfy. Either condition + stops the Version Packages PR and the publish alike. A changeset-side guard + sees neither — which is why the hand-applied 3.0.5 bump needed this one. + **Whether the gate is blocking anything right now is a question for the + registry, not for this file: run `node scripts/release-gate.mjs` and read what + it says.** `tests.yml` runs the same script at PR time so the answer arrives a + merge earlier. Delete the `@cipherstash/eql` entry in the Phase-5 cutover — + `scripts/__tests__/frozen-publisher-docs.test.mjs` fails until this paragraph + goes with it — and note the FFI half of that map is what turns + `lint-no-ffi-changeset.mjs`'s unstated assumption + ("all seven are already on npm at the workspace version") into a checked one. + Note too that 3.0.5 did *not* come from `changeset version` — + eleven unrelated changesets were pending, so the bump was entered by hand in + `packages/eql/packages/eql/CHANGELOG.md` and the parked + `rename-ste-vec-contains.md.deferred` deleted with it, precisely so the + cutover cannot apply the same bump twice. Read that CHANGELOG entry before + assuming a version's provenance. +- **Changesets for `@cipherstash/eql` go in the repo-root `.changeset/`.** + `packages/eql/.changeset/` is an empty leftover of the subtree. + ## Agent Skills — these ship to customers `skills/*/SKILL.md` are **published artifacts, not internal notes.** Treat a wrong diff --git a/SECURITY.md b/SECURITY.md index 7cde6b1bf..e4c960dab 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -19,6 +19,18 @@ This repository is the CipherStash Stack monorepo for JavaScript/TypeScript. It | `@cipherstash/wizard` | AI-powered encryption setup | | `@cipherstash/protect-ffi` | Native FFI bindings to the CipherStash Client SDK — the Rust core `@cipherstash/stack` encrypts and decrypts through | | `@cipherstash/protect-ffi-darwin-arm64`
`@cipherstash/protect-ffi-darwin-x64`
`@cipherstash/protect-ffi-linux-arm64-gnu`
`@cipherstash/protect-ffi-linux-x64-gnu`
`@cipherstash/protect-ffi-linux-x64-musl`
`@cipherstash/protect-ffi-win32-x64-msvc` | Prebuilt per-platform binaries for `@cipherstash/protect-ffi`. Installed as optional dependencies; one is selected at load time for the host platform | +| `@cipherstash/eql` | Encrypt Query Language — the PostgreSQL SQL bundle (`eql_v3` schema: domains, operators, index-term extractors) that stores and queries encrypted payloads, plus its generated TypeScript types. Applied by `stash eql install` and by the Prisma Next adapter's migrations. Released in lockstep with the `eql-bindings` Rust crate, which emits the payloads this SQL reads | + +This repository also carries the source of the **`eql-bindings`** Rust crate +(`packages/eql/crates/eql-bindings`), published to crates.io and released in +lockstep with `@cipherstash/eql`. It is in scope for security reports on the +same terms as the npm packages above. + +> **Note on publishing.** `@cipherstash/eql`, `eql-bindings`, and the seven +> `@cipherstash/protect-ffi*` packages have been absorbed into this repository +> but are still *published* from `cipherstash/encrypt-query-language` and +> `cipherstash/protectjs-ffi` respectively, pending an npm trusted-publishing +> cutover. Their source, issues, and security reports belong here. **Security fixes are released for the latest release line of each package.** Security reports are welcome for any version, but fixes land in the latest release — if you are running an older major version, plan to upgrade to receive them. diff --git a/biome.json b/biome.json index 987de3c3d..4e94394bc 100644 --- a/biome.json +++ b/biome.json @@ -1,5 +1,5 @@ { - "$schema": "https://biomejs.dev/schemas/2.5.2/schema.json", + "$schema": "https://biomejs.dev/schemas/2.5.3/schema.json", "files": { "includes": [ "**", diff --git a/docs/plans/2026-08-13-eql-monorepo-absorption.md b/docs/plans/2026-08-13-eql-monorepo-absorption.md index 2f2a7f4ea..714e287a4 100644 --- a/docs/plans/2026-08-13-eql-monorepo-absorption.md +++ b/docs/plans/2026-08-13-eql-monorepo-absorption.md @@ -315,7 +315,7 @@ Five surfaces, each flipped independently, each inert until its own cutover. - [ ] **Carried over from Phase 4, deliberately.** Port `lint-release.yml` and the two reusable workflows (`_build-sql.yml`, `_build-docs.yml`) alongside the release workflows they gate and are called from — a lint aimed at four absent files is worse than no lint. Add `cache: false` to the three `jdx/mise-action` steps that omit it (`_build-sql.yml`, `_build-docs.yml`, `release-postgres-eql-image.yml`), and add those two plus `release-plz.yml` to `scripts/lint-no-workflow-caching.mjs`'s `TARGETS`, with their remote actions in `AUDITED_ACTIONS` — or the gate fails on the addition itself. - [ ] **Then delete `packages/eql/.github/` entirely**, and convert the shrinking allowlist in `scripts/__tests__/eql-suite-ci.test.mjs` to a straight `existsSync(...) === false`, alongside the existing protect-ffi assertion in `lintWiring.test.ts`. The allowlist is an equality, so it will already be failing by the time the last file goes — that is what makes this step forced rather than remembered. -- [ ] Add `scripts/lint-no-eql-changeset.mjs` in the shape of the FFI guard, so an `@cipherstash/eql` changeset parks as `.changeset/.md.deferred` until npm publishing actually moves. Carry the pending `rename-ste-vec-contains.md` in parked form. +- [x] ~~Add `scripts/lint-no-eql-changeset.mjs` in the shape of the FFI guard~~ — **superseded, and do not restore the parked changeset.** The guard landed instead as `FROZEN_PUBLISHERS` in `scripts/release-gate.mjs`, which is strictly stronger: it exits non-zero on any frozen package whose committed version is missing from npm *and* on any runtime `workspace:` range only that package could satisfy, a pair of conditions no changeset-side guard can see — which is why the hand-applied 3.0.5 bump needed this guard rather than that one. (Run `node scripts/release-gate.mjs` for what it blocks at any given moment; that answer comes from the registry and is not recorded here.) It runs at PR time via `tests.yml` and at release time via `release.yml`. `.changeset/rename-ste-vec-contains.md.deferred` was deleted deliberately in `9b1c44d9` — the 3.0.5 bump was entered by hand in the CHANGELOG, so re-parking that `major` changeset would make the cutover bump the package a second time (3.0.5 → 4.0.0) for a rename already released. **Phase-5 action: delete the `@cipherstash/eql` entry from `FROZEN_PUBLISHERS`, nothing more.** - [ ] Repoint all EQL manifests at `cipherstash/stack`: `packages/eql/packages/eql/package.json` — `repository.url`, `repository.directory` → `packages/eql/packages/eql`, **and `bugs.url`** (line 13, still `encrypt-query-language/issues`, which would send users to an archived repo) — plus `crates/eql-bindings/Cargo.toml` (`repository`, `homepage`) and `release-plz.toml`'s prose. npm and crates.io both reject a publish whose repository field does not match; `bugs.url` is not enforced, which is why it is the one that survives a cutover unnoticed. - [ ] Port `release.yml`'s EQL half into this repo's `release.yml` — the existing gate-then-publish structure already models "one version authority plus N idempotent publishers", which is the shape it was derived from. Preserve the `classify` prerelease path and the `eql-typescript-v` idempotency short-circuit. - [ ] Port `release-plz.yml` unchanged in filename — crates.io trusted publishing binds to it. diff --git a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json index 4f472477d..230c7f589 100644 --- a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json +++ b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json @@ -8,5 +8,5 @@ "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1" ], "createdAt": "2026-07-14T20:10:24.325Z", - "migrationHash": "sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05" + "migrationHash": "sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313" } \ No newline at end of file diff --git a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json index adc7748c5..d86ac25cf 100644 --- a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json +++ b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json @@ -11,7 +11,7 @@ "execute": [ { "description": "Install EQL v3 bundle (eql-3.0.5: public.eql_v3_* domains + eql_v3.* functions)", - "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" + "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" } ], "postcheck": [ diff --git a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json index 32e3cff6e..7c2a1d021 100644 --- a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json +++ b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json @@ -5,5 +5,5 @@ "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1" ], "createdAt": "2026-08-14T00:45:14.365Z", - "migrationHash": "sha256:7bafd9d6c5d244332ff0b0943604dbd026c8369e24d2f335b1365c5f78e49d38" + "migrationHash": "sha256:3b2b838bee634f2de4a5e88f1625a45d47c327e3021b0e2ccba36c09a9666178" } \ No newline at end of file diff --git a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json index 75c24c890..cc6bd650c 100644 --- a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json +++ b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json @@ -11,7 +11,7 @@ "execute": [ { "description": "Upgrade EQL v3 bundle to eql-3.0.5", - "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" + "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" } ], "postcheck": [ diff --git a/package.json b/package.json index c9035a76f..a279d3109 100644 --- a/package.json +++ b/package.json @@ -23,8 +23,8 @@ "build": "turbo build --filter './packages/*'", "build:js": "turbo build --filter './packages/nextjs'", "changeset": "changeset", - "changeset:version": "changeset version", - "changeset:publish": "changeset publish", + "changeset:version": "pnpm run version", + "changeset:publish": "pnpm run release", "dev": "turbo dev --filter './packages/*'", "clean": "rimraf --glob **/.next **/.turbo **/dist **/node_modules", "code:fix": "biome check --write", diff --git a/packages/eql/Cargo.lock b/packages/eql/Cargo.lock index 344e2c6d6..e76325bbd 100644 --- a/packages/eql/Cargo.lock +++ b/packages/eql/Cargo.lock @@ -612,9 +612,9 @@ dependencies = [ [[package]] name = "cipherstash-config" -version = "0.42.0" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56cde3aaa5e2916a40530932f142c37ad6202835a6d221ce6c46fc14bfec8fc5" +checksum = "b94efb31c4b6cc951f2ed2c2a953393ba34136c37c5ddd022a8da732f174e532" dependencies = [ "bitflags", "serde", @@ -872,9 +872,9 @@ dependencies = [ [[package]] name = "cts-common" -version = "0.42.0" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe2acdda527057d48061433ace5378d8452f10d6787f78e0e69b1cddacc57082" +checksum = "576c82618990e693abe4dfbd06dada0bcb45884a4514405851eec6d82818f52c" dependencies = [ "arrayvec", "base32", @@ -2127,17 +2127,20 @@ dependencies = [ [[package]] name = "jsonwebtoken" -version = "9.3.1" +version = "10.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde" +checksum = "eba32bfb4ffdeaca3e34431072faf01745c9b26d25504aa7a6cf5684334fc4fc" dependencies = [ + "aws-lc-rs", "base64", + "getrandom 0.2.16", "js-sys", "pem", - "ring", "serde", "serde_json", + "signature", "simple_asn1", + "zeroize", ] [[package]] @@ -3855,9 +3858,9 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "stack-auth" -version = "0.42.0" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d1c9c640571eba8fa5a705ccebe5c5e50aa27d4d51f4ec1614ffd1841b8a13a" +checksum = "f1a9ac43060af7605899754daa3de2e26302c2ab4d9249a8bc16157bc53dad65" dependencies = [ "aquamarine", "base64", @@ -3883,9 +3886,9 @@ dependencies = [ [[package]] name = "stack-profile" -version = "0.42.0" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "192a90bfa46efe194c2b8beae5523f6214714574c7e8a210c78021259f100e79" +checksum = "90ce7ca95d8e688a35e86e0682293a2085d9b1f26e7ca5b489009c6ee0c6967a" dependencies = [ "dirs", "gethostname", @@ -5415,9 +5418,9 @@ dependencies = [ [[package]] name = "zerokms-protocol" -version = "0.12.26" +version = "0.12.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "16f731f2de99e66396928faef44b02b39288dc9a93f77a4a3e1dcdc33c1adad0" +checksum = "29486723fdd2bdb0c234174dc242051a46ac0c82935ccaa39e9781dbf7bcc6d2" dependencies = [ "base64", "cipherstash-config", diff --git a/packages/eql/crates/eql-bindings/sql/cipherstash-encrypt.sql b/packages/eql/crates/eql-bindings/sql/cipherstash-encrypt.sql index b4237b336..88c460300 100644 --- a/packages/eql/crates/eql-bindings/sql/cipherstash-encrypt.sql +++ b/packages/eql/crates/eql-bindings/sql/cipherstash-encrypt.sql @@ -23444,6 +23444,38 @@ AS $$ @> eql_v3.to_ste_vec_query(b)::jsonb $$; +--! @cond deprecated_compatibility +--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb). +--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb). +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b's selector is present in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.jsonb_document_contains(a, b) +$$; + +COMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS + 'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)'; + +--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search). +--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search). +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_search Elements to find. +--! @return boolean True if all elements of b are contained in a. +CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.jsonb_document_contains(a, b) +$$; + +COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS + 'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)'; +--! @endcond + ------------------------------------------------------------------------------ -- Path queries (text selector only) ------------------------------------------------------------------------------ diff --git a/packages/eql/crates/eql-bindings/sql/release-manifest.json b/packages/eql/crates/eql-bindings/sql/release-manifest.json index 956124903..f0203fcc7 100644 --- a/packages/eql/crates/eql-bindings/sql/release-manifest.json +++ b/packages/eql/crates/eql-bindings/sql/release-manifest.json @@ -1,6 +1,6 @@ { "eqlVersion": "3.0.5", "schemaVersion": 3, - "installSqlSha256": "7ad9c9f884083979c1cf483ff4f68d2569257d6c6fab15d9e4586f4c93703cad", + "installSqlSha256": "accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/packages/eql/docs/upgrading/v3.0.5.md b/packages/eql/docs/upgrading/v3.0.5.md new file mode 100644 index 000000000..d03887520 --- /dev/null +++ b/packages/eql/docs/upgrading/v3.0.5.md @@ -0,0 +1,168 @@ +# Upgrading to EQL 3.0.5 + +`3.0.5` is a patch release carrying one rename in the public `eql_v3` surface, +with the old name retained as a deprecated alias. **Nothing in it requires you +to change any SQL.** It is a patch, not a major, for the reason 3.0.1 was: a +patch reaches every consumer already on a `^3.x` range at their next install — +and with the alias in place there is no compatibility argument left to have. + +This guide also records a second thing, which is **not** new in 3.0.5 but bites +hardest at upgrade time and has never had a note of its own: applying the EQL +bundle drops and recreates its schemas, so grants and dependent objects do not +survive it. + +## TL;DR + +1. `eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains`. + The old name still works — it is now a deprecated alias. Migrate at your + convenience — [U-001](#u-001-the-containment-implementation-is-renamed). +2. Applying any EQL bundle destroys grants, indexes and dependent objects in + `eql_v3` / `eql_v3_internal`; re-apply them afterwards — + [U-002](#u-002-grants-and-dependent-objects-do-not-survive-an-install). + +## Compatibility + +| Surface | Status | +| --- | --- | +| `@>` / `<@` on `public.eql_v3_json_search` | **Unchanged.** Same operators, same results, same index behaviour. | +| `eql_v3.jsonb_contains(jsonb, jsonb)` / `eql_v3.jsonb_contained_by(jsonb, jsonb)` | **Unchanged**, byte for byte. These are the function-form entry points for platforms without operator support — PostgREST included — and they are not affected by this release. | +| `eql_v3.ste_vec_contains` | **Renamed** to `eql_v3.jsonb_document_contains` (both overloads), with the old name kept as a deprecated delegating alias — existing callers keep working. See U-001. | +| `eql_v3.to_ste_vec_query`, `eql_v3.ste_vec`, `eql_v3.jsonb_array` | **Unchanged.** The documented GIN index recipe still reads `USING gin ((eql_v3.to_ste_vec_query(col)::jsonb) jsonb_path_ops)`. | +| Wire format, domains, index terms | **Unchanged.** No re-encryption, no data migration. | + +## Upgrade notes + +### U-001: The containment implementation is renamed + +**What changed.** `eql_v3.ste_vec_contains` is now +`eql_v3.jsonb_document_contains`, in both overloads — +`(jsonb[], jsonb)` and +`(public.eql_v3_json_search, public.eql_v3_json_search)`. The body is +unchanged. **The old name is retained** as a deprecated alias for both +overloads, each delegating to the new one — so this release breaks no caller. + +**Why.** It was the last object in the public surface still carrying +`ste_vec_` naming, after the SteVec entry and query surface became +`jsonb_entry` / `jsonb_query`. `ste_vec` is an implementation detail of the +encrypted representation; the operator family it backs is the `jsonb_*` one. + +**Who is affected.** Nobody is forced to act. In particular this is **not** the +PostgREST story it might look like: PostgREST calls functions rather than +operators, but the function-form containment entry points it calls are +`eql_v3.jsonb_contains` and `eql_v3.jsonb_contained_by`, and both are unchanged. +`jsonb_document_contains` is what the typed `@>` / `<@` operators dispatch into. + +SQL that names the old function directly — application queries, views and +matviews, RLS `USING` / `WITH CHECK` expressions, wrapping functions and +triggers, and per-function `GRANT EXECUTE ON FUNCTION +eql_v3.ste_vec_contains(…)` — all keep resolving, through the alias. + +The typed overload is deliberately `LANGUAGE sql` and stays inlinable, so a +function-form query through the alias still matches the same functional GIN +index it did before the rename. There is no performance cliff for not +migrating. + +**What to do.** Nothing, to upgrade. When convenient, grep your migrations, +policies and application SQL for `ste_vec_contains` and replace it with +`jsonb_document_contains` — same arguments, same return, same semantics. The +alias is marked deprecated in the database itself (`COMMENT ON FUNCTION`), so +`\df+ eql_v3.ste_vec_contains` tells a DBA what to move to. + +**Verification.** + +```sql +-- Must return two rows (the two overloads): +SELECT p.oid::regprocedure +FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace +WHERE n.nspname = 'eql_v3' AND p.proname = 'jsonb_document_contains'; + +-- Must ALSO return two rows — the deprecated aliases, which 3.0.5 keeps: +SELECT p.oid::regprocedure, obj_description(p.oid, 'pg_proc') AS note +FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace +WHERE n.nspname = 'eql_v3' AND p.proname = 'ste_vec_contains'; + +-- The operators are unchanged; this must still work: +SELECT '{"sv": []}'::jsonb::public.eql_v3_json_search + @> '{"sv": []}'::jsonb::public.eql_v3_json_search; -- true +``` + +### U-002: Grants and dependent objects do not survive an install + +**What changed.** Nothing — this has always been true, and it is recorded here +because 3.0.5 is the first release whose *only* change is one that a reader +might otherwise upgrade through without re-running their grants. + +**What to know.** The installer opens with: + +```sql +DROP SCHEMA IF EXISTS eql_v3 CASCADE; +CREATE SCHEMA eql_v3; +DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; +CREATE SCHEMA eql_v3_internal; +``` + +`CASCADE` means every install — first install, upgrade, or re-apply — destroys +everything in those two schemas *and* everything outside them that depended on +their objects. That includes: + +- **all grants** on `eql_v3` / `eql_v3_internal` objects, including those from + `GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA …`, which is a point-in-time grant + and does not cover objects created later +- **functional indexes** over the term extractors (`eql_v3.eq_term`, + `ord_term`, `ord_term_ore`, `match_term`, `to_ste_vec_query`) — these vanish + and queries fall back to sequential scans **without erroring** +- **views, matviews and generated columns** whose definitions reference + `eql_v3` objects + +Your table columns and their data are untouched: the storage domains live in +`public` precisely so they survive an EQL schema uninstall. + +**What to do.** After every install or upgrade, re-apply — in this order — your +grant script and your index DDL, then `ANALYZE`. The schema-wide grant form in +[permissions.md](../reference/permissions.md) picks up renamed and newly added +functions on its own, which is one more reason to prefer it to per-function +grants: + +```sql +GRANT USAGE ON SCHEMA eql_v3 TO app_role; +GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3 TO app_role; +GRANT USAGE ON SCHEMA eql_v3_internal TO app_role; +GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3_internal TO app_role; +``` + +If you run the bundle through a migration runner, put the grants and the +`CREATE INDEX` statements in a *new* migration alongside the upgrade — a runner +skips migrations it has already applied, so the originals will not re-run. + +**Verification.** + +```sql +-- Containment must be executable by the app role after the upgrade: +SELECT has_function_privilege( + 'app_role', + 'eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search)', + 'EXECUTE'); -- must be true + +-- And the functional indexes must still be there: +SELECT indexname FROM pg_indexes +WHERE indexdef LIKE '%eql_v3.%_term%' OR indexdef LIKE '%to_ste_vec_query%'; +``` + +## Rollback + +U-001 needs no rollback: 3.0.5 adds a name and keeps the old one, so anything +that worked on 3.0.4 works on 3.0.5. Installing the 3.0.4 bundle does reverse +it, and is the only way to remove `jsonb_document_contains` — but the reason to +do so would have to come from somewhere other than this rename. Nothing in the +wire format or the stored data changes between 3.0.4 and 3.0.5, so no +re-encryption is involved in either direction — but note that rolling back +re-runs the `DROP SCHEMA … CASCADE` in U-002, so grants and indexes need +re-applying again afterwards. + +## See also + +- [Upgrading to EQL 3.0](./v3.0.md) — the breaking changes in the 3.0 line. +- [Permissions reference](../reference/permissions.md) — what each query path + needs granted, and the schema-wide grant script. +- [Database indexes](../reference/database-indexes.md) — the index recipes to + re-apply after an install. diff --git a/packages/eql/docs/upgrading/v3.0.md b/packages/eql/docs/upgrading/v3.0.md index 880f5eaac..573c63613 100644 --- a/packages/eql/docs/upgrading/v3.0.md +++ b/packages/eql/docs/upgrading/v3.0.md @@ -54,7 +54,7 @@ the `eql_v3` surface (U-001 through U-010 below). | Text bloom fuzzy match (`public.eql_v3_text_match` / `text_search` / `text_search_ore`) | **Changed.** `@>` / `<@` (`eql_v3.contains` / `contained_by`) → the single directional `@@` (`eql_v3.matches`); `@>` / `<@` now raise on these domains — see U-008. | | Empty-bloom fuzzy-match needle (`@@` / `eql_v3.matches`) | **Changed.** An empty needle bloom matched every row (vacuous containment); now `LIKE ''`-shaped — matches only empty-bloom values. Normal queries and the GIN index recipe unchanged — see U-011. | | Uninstaller lock footprint | **Grown.** The single-transaction uninstall takes ~6,400+ locks — at/over the default `max_locks_per_transaction = 64` cluster budget under concurrent load — see U-009. Installation unaffected. | -| JSON containment (`public.eql_v3_json_search` `@>` / `<@`, `eql_v3.ste_vec_contains`) | **Unchanged.** Genuine containment keeps the containment vocabulary — see U-008. | +| JSON containment (`public.eql_v3_json_search` `@>` / `<@`, `eql_v3.jsonb_document_contains`) | **Unchanged.** Genuine containment keeps the containment vocabulary — see U-008. (The implementation was called `eql_v3.ste_vec_contains` until 3.0.5 renamed it; the operators never changed. See [Upgrading to EQL 3.0.5](./v3.0.5.md).) | | Legacy `eql_v2` wire documentation (`docs/reference/schema/eql-payload-v2.*.schema.json`) | **Unchanged.** Stays `v: 2`. | ## Upgrade notes @@ -609,7 +609,8 @@ order- and multiplicity-insensitive, one-sided fuzzy match: a `true` may be a false positive; a `false` never is. Naming it `contains` / `@>` promised substring/containment semantics it does not provide, and collided with the genuine containment surface on encrypted JSON (`public.eql_v3_json_search`, -`eql_v3.ste_vec_contains`), which is unaffected and keeps `@>` / `<@`. This is the +`eql_v3.jsonb_document_contains` — named `eql_v3.ste_vec_contains` before +3.0.5), which is unaffected and keeps `@>` / `<@`. This is the SQL-layer counterpart of the SDK's `contains()` → `matches()` rename. **Who is affected.** Anyone with a query, view, or SDK/adapter that emits @@ -767,7 +768,8 @@ equality on the extract surface; anyone calling `eql_v3.jsonb_array_elements_tex `eql_v3.jsonb_array_elements(col)` — its entry rows carry the grafted key header and are the decryptable unit. - Range queries, document-to-document containment (`@>` / `<@`, - `eql_v3.ste_vec_contains`), field/array access (`->`, `->>`), ordered + `eql_v3.jsonb_document_contains`, called `eql_v3.ste_vec_contains` before + 3.0.5), field/array access (`->`, `->>`), ordered entry-to-entry comparison, `eql_v3.ord_term`, and `min` / `max` are unchanged. Entry-to-entry `=` / `<>` now fail loudly; use value-selector containment for exact equality. diff --git a/packages/eql/packages/eql/CHANGELOG.md b/packages/eql/packages/eql/CHANGELOG.md index 9de166a43..1942b9676 100644 --- a/packages/eql/packages/eql/CHANGELOG.md +++ b/packages/eql/packages/eql/CHANGELOG.md @@ -8,13 +8,30 @@ consolidates the last `ste_vec_*`-named public object into the `jsonb_*` family, matching the earlier renames of the SteVec entry/query surface (`jsonb_entry`, `jsonb_query`). The function backs the `json` `@>` / `<@` containment operators; - its behaviour is unchanged. Callers that invoke the function by name (Supabase / - PostgREST, which call functions rather than operators) must update the name. + its behaviour is unchanged. + + **Nothing breaks.** The old name remains as a deprecated delegating alias, both + overloads, so direct callers keep working. The operators never moved, and + neither did the two function-form entry points a PostgREST deployment actually + calls — `eql_v3.jsonb_contains(jsonb, jsonb)` and + `eql_v3.jsonb_contained_by(jsonb, jsonb)` are byte-identical to 3.0.4. Hand-written + SQL naming `ste_vec_contains` — queries, views, RLS policies, per-function + `GRANT`s — continues to resolve; update it at your convenience, not under + pressure. See [U-001](../../docs/upgrading/v3.0.5.md#u-001-the-containment-implementation-is-renamed). + + **The thing in this release that does have consequences is not the rename.** + The installer opens with `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so *every* EQL + install drops grants, functional indexes and dependent views — true of every + release, not just this one, and now the only item here with operational weight. + See [U-002](../../docs/upgrading/v3.0.5.md#u-002-grants-and-dependent-objects-do-not-survive-an-install). Released as a **patch**, matching 3.0.1, which shipped the fuzzy-match operator change (`@>` / `<@` → `@@`) at the same level. The parked changeset proposed `major`; a patch reaches every consumer already on a `^3.x` range at their next - install, which a major would not have done. + install, which a major would not have done — and with the alias in place the + patch level is not a judgement call at all. Upstream reached the same + conclusion independently, retargeting its own changeset from `major` to `patch` + in the commit that restored the aliases. Entered by hand rather than by `changeset version`. The rename landed in the tree with the monorepo import and was never released, so the package shipped @@ -25,6 +42,22 @@ `.changeset/rename-ste-vec-contains.md.deferred` is deleted with it, so the cutover cannot apply the same bump a second time. + The SQL that actually shipped is upstream's, not this tree's: `@cipherstash/eql@3.0.5` + was published from `cipherstash/encrypt-query-language` (the last release from + there) and carries the restored aliases from upstream `142f41d8`, which this + tree did not have when the entry above was first written. The subtree was + re-synced to that release so the bundle here is byte-identical to the published + one — `installSqlSha256: accde0030…`. The generated entry below is upstream's + own changeset for the same release. +- 4c2bb92: **`eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains`.** This + consolidates the last `ste_vec_*`-named public object into the `jsonb_*` family, + matching the earlier renames of the SteVec entry/query surface (`jsonb_entry`, + `jsonb_query`). The old name remains available as a deprecated compatibility + alias, so existing direct callers continue to work; new code should use + `jsonb_document_contains`. The `json` `@>` / `<@` containment operators and the + raw-jsonb function-form entry points, `eql_v3.jsonb_contains(jsonb, jsonb)` and + `eql_v3.jsonb_contained_by(jsonb, jsonb)`, are unchanged. + ## 3.0.4 ### Patch Changes diff --git a/packages/eql/packages/eql/sql/cipherstash-encrypt.sql b/packages/eql/packages/eql/sql/cipherstash-encrypt.sql index b4237b336..88c460300 100644 --- a/packages/eql/packages/eql/sql/cipherstash-encrypt.sql +++ b/packages/eql/packages/eql/sql/cipherstash-encrypt.sql @@ -23444,6 +23444,38 @@ AS $$ @> eql_v3.to_ste_vec_query(b)::jsonb $$; +--! @cond deprecated_compatibility +--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb). +--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb). +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b's selector is present in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.jsonb_document_contains(a, b) +$$; + +COMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS + 'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)'; + +--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search). +--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search). +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_search Elements to find. +--! @return boolean True if all elements of b are contained in a. +CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.jsonb_document_contains(a, b) +$$; + +COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS + 'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)'; +--! @endcond + ------------------------------------------------------------------------------ -- Path queries (text selector only) ------------------------------------------------------------------------------ diff --git a/packages/eql/packages/eql/sql/release-manifest.json b/packages/eql/packages/eql/sql/release-manifest.json index 956124903..f0203fcc7 100644 --- a/packages/eql/packages/eql/sql/release-manifest.json +++ b/packages/eql/packages/eql/sql/release-manifest.json @@ -1,6 +1,6 @@ { "eqlVersion": "3.0.5", "schemaVersion": 3, - "installSqlSha256": "7ad9c9f884083979c1cf483ff4f68d2569257d6c6fab15d9e4586f4c93703cad", + "installSqlSha256": "accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/packages/eql/packages/eql/src/generated/release-manifest.ts b/packages/eql/packages/eql/src/generated/release-manifest.ts index 8a99a623b..21c403c1c 100644 --- a/packages/eql/packages/eql/src/generated/release-manifest.ts +++ b/packages/eql/packages/eql/src/generated/release-manifest.ts @@ -1,6 +1,6 @@ export const releaseManifest = { eqlVersion: '3.0.5', schemaVersion: 3, - installSqlSha256: '7ad9c9f884083979c1cf483ff4f68d2569257d6c6fab15d9e4586f4c93703cad', + installSqlSha256: 'accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048', uninstallSqlSha256: 'b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9', } as const diff --git a/packages/eql/src/v3/json/functions.sql b/packages/eql/src/v3/json/functions.sql index e5770dde7..fa8acdc2f 100644 --- a/packages/eql/src/v3/json/functions.sql +++ b/packages/eql/src/v3/json/functions.sql @@ -349,6 +349,38 @@ AS $$ @> eql_v3.to_ste_vec_query(b)::jsonb $$; +--! @cond deprecated_compatibility +--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb). +--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb). +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b's selector is present in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.jsonb_document_contains(a, b) +$$; + +COMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS + 'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)'; + +--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search). +--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search). +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_search Elements to find. +--! @return boolean True if all elements of b are contained in a. +CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.jsonb_document_contains(a, b) +$$; + +COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS + 'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)'; +--! @endcond + ------------------------------------------------------------------------------ -- Path queries (text selector only) ------------------------------------------------------------------------------ diff --git a/packages/eql/tasks/docs/doxygen-filter.sh b/packages/eql/tasks/docs/doxygen-filter.sh index 0b5313bdb..fe00c19ab 100755 --- a/packages/eql/tasks/docs/doxygen-filter.sh +++ b/packages/eql/tasks/docs/doxygen-filter.sh @@ -10,10 +10,13 @@ if [ "$#" -ne 1 ]; then exit 2 fi -# Prepares SQL for Doxygen's C++ parser. Three transforms: +# Prepares SQL for Doxygen's C++ parser. Four transforms: # -# 1. `--!` doc comments -> `//!` so Doxygen sees them. -# 2. Strip dollar-quoted function bodies (`$$ ... $$`), leaving just the +# 1. Omit blocks marked `@cond deprecated_compatibility`. These functions +# remain callable for backwards compatibility but must not appear in the +# generated function reference or source browser. +# 2. `--!` doc comments -> `//!` so Doxygen sees them. +# 3. Strip dollar-quoted function bodies (`$$ ... $$`), leaving just the # declaration and its trailing clauses. Doxygen parses SQL heuristically as # C++, and body SQL derails it: a `::type` cast reads as C++ scope # resolution and drops the whole enclosing CREATE FUNCTION memberdef (this @@ -23,7 +26,7 @@ fi # documentation, so removing them is lossless for the generated reference # and leaves Doxygen only clean `CREATE FUNCTION name(args) RETURNS ...` # declarations to read. Only bare `$$` quoting is used in this codebase. -# 3. Strip CREATE AGGREGATE definition bodies, for the same reason and with the +# 4. Strip CREATE AGGREGATE definition bodies, for the same reason and with the # same losslessness: `sfunc`/`stype`/`combinefunc`/`parallel` carry no # documentation. The trailing `( ... )` is a SECOND parenthesised group # after the signature, and C++ has no such form, so Doxygen misreads the @@ -39,6 +42,17 @@ fi # Reducing each to a single `CREATE AGGREGATE name(argtype);` declaration # recovers the name in both cases and leaves a clean argument list. awk ' + /^--![[:space:]]+@cond[[:space:]]+deprecated_compatibility[[:space:]]*$/ { + inhidden = 1 + print "" + next + } + inhidden && /^--![[:space:]]+@endcond[[:space:]]*$/ { + inhidden = 0 + print "" + next + } + inhidden { print ""; next } /^--!/ { print "//!" substr($0, 4); next } # Emit the signature up to its balanced closing paren, then skip the body. !inagg && /^[[:space:]]*CREATE[[:space:]]+AGGREGATE/ { diff --git a/packages/eql/tasks/test/docs_v3_grep.sh b/packages/eql/tasks/test/docs_v3_grep.sh index 8eeff97a3..14cc27c67 100755 --- a/packages/eql/tasks/test/docs_v3_grep.sh +++ b/packages/eql/tasks/test/docs_v3_grep.sh @@ -62,8 +62,37 @@ for f in "${DOC_FILES[@]}"; do fi done +# Deprecated SQL compatibility aliases remain installed, but the explicitly +# hidden block must never reach Doxygen — including its generated source browser. +ste_vec_alias_count=$(grep -c '^CREATE FUNCTION eql_v3\.ste_vec_contains' src/v3/json/functions.sql || true) +if [ "$ste_vec_alias_count" -ne 2 ]; then + echo "FAIL: expected both deprecated ste_vec_contains overloads in src/v3/json/functions.sql" >&2 + status=1 +else + # CAPTURE, THEN MATCH — never `doxygen-filter.sh ... | grep -q ...`. `grep -q` + # exits at the first match and closes the pipe; the filter's awk then takes + # SIGPIPE and exits 141, and `set -o pipefail` makes that the pipeline's + # status. So the LEAK path — the one this guard exists for — scored as "no + # match" and the FAIL branch never ran, while the clean path (grep reads to + # EOF, exits 1) reported correctly. A check that can only ever say OK. + # + # Measured at 141 against the real filter output on macOS. Linux's larger + # pipe buffer absorbed the ~16 KB and hid it, so this was a platform split + # rather than an obvious bug. Guarded repo-wide by + # scripts/__tests__/workflow-grep-q-pipelines.test.mjs. + # + # A separate assignment also means `set -e` aborts if the filter itself + # fails, instead of the old pipeline quietly scoring a crashed filter as a + # pass. + filtered_sql=$(tasks/docs/doxygen-filter.sh src/v3/json/functions.sql) + if grep -q 'ste_vec_contains' <<< "$filtered_sql"; then + echo "FAIL: deprecated ste_vec_contains aliases leaked through the Doxygen input filter" >&2 + status=1 + fi +fi + if [ "$status" -eq 0 ]; then - echo "OK: no user-facing doc references eql_v2 (${#DOC_FILES[@]} files scanned)." + echo "OK: user-facing docs contain neither eql_v2 nor the hidden ste_vec_contains alias (${#DOC_FILES[@]} files scanned)." else echo >&2 echo "The eql_v2 surface was removed in 3.0.0; user-facing docs must teach only eql_v3." >&2 diff --git a/packages/eql/tasks/test/splinter.sh b/packages/eql/tasks/test/splinter.sh index af7c7e98a..058689892 100755 --- a/packages/eql/tasks/test/splinter.sh +++ b/packages/eql/tasks/test/splinter.sh @@ -103,6 +103,7 @@ function_search_path_mutable eql_v3 selector function STE-vec entry selector ext function_search_path_mutable eql_v3 ope_term function STE-vec ordered-term extractor for public.eql_v3_jsonb_entry: inlinable so `eql_v3.ope_term(col -> 'sel')` folds into the calling range query and matches the functional btree index built on the same expression. SET search_path would disable SQL function inlining. The deprecated eq_term(json_entry) compatibility alias is pinned and does not surface. 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.eql_v3_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_document_contains function Typed encrypted-JSONB document containment engine backing the public.eql_v3_json_search @>/<@ operators: the inlinable SQL (public.eql_v3_json_search) overload folds to native jsonb containment over eql_v3.to_ste_vec_query(a/b)::jsonb, so the planner can match the functional GIN index on eql_v3.to_ste_vec_query(col)::jsonb. Structural domain-arg skip leaves this overload unpinned; the raw jsonb[] plpgsql overload has a fixed search_path and does not surface. +function_search_path_mutable eql_v3 ste_vec_contains function Deprecated compatibility alias for the typed eql_v3.jsonb_document_contains overload. It must remain inlinable so existing function-form queries retain the same functional-GIN-index matching as before the rename. The public.eql_v3_json_search domain arguments leave this overload intentionally unpinned; the raw jsonb[] alias is pinned by tasks/pin_search_path_v3.sql and does not surface. 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/packages/eql/tests/sqlx/snapshots/eql_v3_public_surface.txt b/packages/eql/tests/sqlx/snapshots/eql_v3_public_surface.txt index 1f7ace6ed..85c9bfaf6 100644 --- a/packages/eql/tests/sqlx/snapshots/eql_v3_public_surface.txt +++ b/packages/eql/tests/sqlx/snapshots/eql_v3_public_surface.txt @@ -1272,6 +1272,8 @@ function eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) function eql_v3.selector(entry public.eql_v3_json_entry) function eql_v3.selector(val jsonb) function eql_v3.ste_vec(val jsonb) +function eql_v3.ste_vec_contains(a jsonb[], b jsonb) +function eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) function eql_v3.to_ste_vec_query(e eql_v3.query_json) function eql_v3.to_ste_vec_query(e public.eql_v3_json_search) function eql_v3.version() diff --git a/packages/eql/tests/sqlx/snapshots/v3_jsonb_tests.txt b/packages/eql/tests/sqlx/snapshots/v3_jsonb_tests.txt index ff91adb50..eb19bb897 100644 --- a/packages/eql/tests/sqlx/snapshots/v3_jsonb_tests.txt +++ b/packages/eql/tests/sqlx/snapshots/v3_jsonb_tests.txt @@ -33,6 +33,7 @@ v3_jsonb_generator_envelope_shape_accepted v3_jsonb_index_ord_ope_btree_engages v3_jsonb_index_to_ste_vec_query_gin_engages v3_jsonb_json_payload_check +v3_jsonb_legacy_ste_vec_contains_aliases v3_jsonb_minus_array_blocker v3_jsonb_minus_int_blocker v3_jsonb_minus_text_blocker diff --git a/packages/eql/tests/sqlx/tests/v3_jsonb_tests.rs b/packages/eql/tests/sqlx/tests/v3_jsonb_tests.rs index 3e71b96e7..8e157937c 100644 --- a/packages/eql/tests/sqlx/tests/v3_jsonb_tests.rs +++ b/packages/eql/tests/sqlx/tests/v3_jsonb_tests.rs @@ -602,6 +602,36 @@ async fn v3_jsonb_raw_helpers_contains_and_contained_by(pool: PgPool) -> anyhow: Ok(()) } +/// Both deprecated `ste_vec_contains` overloads remain callable over a real +/// CipherStash-generated SteVec payload and agree with their replacement. +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_ste_vec")))] +async fn v3_jsonb_legacy_ste_vec_contains_aliases(pool: PgPool) -> anyhow::Result<()> { + let (legacy_raw, current_raw, legacy_typed, current_typed): (bool, bool, bool, bool) = + sqlx::query_as( + "SELECT \ + eql_v3.ste_vec_contains(\ + eql_v3.ste_vec(payload::jsonb), \ + (eql_v3.ste_vec(payload::jsonb))[1]), \ + eql_v3.jsonb_document_contains(\ + eql_v3.ste_vec(payload::jsonb), \ + (eql_v3.ste_vec(payload::jsonb))[1]), \ + eql_v3.ste_vec_contains(payload, payload), \ + eql_v3.jsonb_document_contains(payload, payload) \ + FROM fixtures.v3_ste_vec \ + ORDER BY id \ + LIMIT 1", + ) + .fetch_one(&pool) + .await?; + + assert!(legacy_raw, "legacy raw alias must find a real sv entry"); + assert_eq!(legacy_raw, current_raw); + assert!(legacy_typed, "legacy typed alias must contain itself"); + assert_eq!(legacy_typed, current_typed); + + Ok(()) +} + /// `eql_v3.ord_term(jsonb_entry)` has no `has_*` companion: absence of an /// `op` term is signalled by the extractor returning SQL NULL (which a /// functional btree index stores and comparisons skip). Dedicated diff --git a/packages/protect-ffi/Cargo.lock b/packages/protect-ffi/Cargo.lock index 845d99445..c9f921fa0 100644 --- a/packages/protect-ffi/Cargo.lock +++ b/packages/protect-ffi/Cargo.lock @@ -1058,7 +1058,7 @@ dependencies = [ [[package]] name = "eql-bindings" -version = "3.0.4" +version = "3.0.5" dependencies = [ "schemars", "serde", @@ -1079,7 +1079,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -3021,7 +3021,7 @@ dependencies = [ "security-framework", "security-framework-sys", "webpki-root-certs", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -3357,7 +3357,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -4388,7 +4388,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.61.2", + "windows-sys 0.48.0", ] [[package]] diff --git a/packages/stack-prisma/README.md b/packages/stack-prisma/README.md index cc7367fe1..5e5197657 100644 --- a/packages/stack-prisma/README.md +++ b/packages/stack-prisma/README.md @@ -29,6 +29,41 @@ Declare encrypted columns directly in `schema.prisma`, and the framework's migra npm install @cipherstash/stack @cipherstash/stack-prisma ``` +### Upgrading from 1.0.0 + +1.0.0 shipped the EQL v3 baseline migration at **eql-3.0.4**. Later versions bake +**eql-3.0.5** into the same baseline directory +(`20260601T0100_install_eql_v3_bundle`), so its bytes — and its `migrationHash` — +changed. Migration packages are content-addressed and copied into your repo, and +the CLI's seed phase never rewrites a directory that already exists, so a +`migrations/cipherstash/` generated against 1.0.0 keeps the old baseline forever. + +**After upgrading, delete the vendored directory and regenerate it:** + +```bash +rm -rf migrations/cipherstash +npx prisma-next migration plan +``` + +Your database is untouched by this: markers are keyed by invariant, so +already-applied invariants are not re-run and the only new work is the 3.0.5 +upgrade edge. + +Skipping this is not always fatal, which is why it is easy to miss: + +| You run | With a stale `migrations/cipherstash/` | +| --- | --- | +| `prisma-next migration plan` | Succeeds. The stale baseline is kept silently — there is no hash mismatch, because it is intact, just old. | +| `prisma-next migrate` (existing database) | Correct: applies the 3.0.5 upgrade edge only. | +| `prisma-next migrate` (fresh database) | Correct end state, but installs eql-3.0.4 and then immediately re-installs eql-3.0.5 over it. | +| `prisma-next db init` (fresh database) | **Fails**: `Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is not allowed by policy.` `db init` is additive-only, and the stale baseline does not carry the 3.0.5 invariant, so the planner has to reach for the data-classed upgrade edge. The message does not say so — the remedy is the `rm -rf` above. | + +Note that only `prisma-next migration plan` copies new migration packages into +your repo. If you upgrade the package and run `prisma-next migrate` or +`db init` **without** planning first, the 3.0.5 upgrade is not on disk yet and is +silently skipped — your database stays on the older bundle. Always run +`migration plan` after upgrading. + ## Quick start ```prisma diff --git a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json index 4f472477d..230c7f589 100644 --- a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json +++ b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json @@ -8,5 +8,5 @@ "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1" ], "createdAt": "2026-07-14T20:10:24.325Z", - "migrationHash": "sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05" + "migrationHash": "sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313" } \ No newline at end of file diff --git a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json index adc7748c5..d86ac25cf 100644 --- a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json +++ b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json @@ -11,7 +11,7 @@ "execute": [ { "description": "Install EQL v3 bundle (eql-3.0.5: public.eql_v3_* domains + eql_v3.* functions)", - "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" + "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" } ], "postcheck": [ diff --git a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json index 32e3cff6e..7c2a1d021 100644 --- a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json +++ b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json @@ -5,5 +5,5 @@ "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1" ], "createdAt": "2026-08-14T00:45:14.365Z", - "migrationHash": "sha256:7bafd9d6c5d244332ff0b0943604dbd026c8369e24d2f335b1365c5f78e49d38" + "migrationHash": "sha256:3b2b838bee634f2de4a5e88f1625a45d47c327e3021b0e2ccba36c09a9666178" } \ No newline at end of file diff --git a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts index 1f0bef285..75b302b9e 100644 --- a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts +++ b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts @@ -4,8 +4,9 @@ * * 3.0.5 renames `eql_v3.ste_vec_contains` to `eql_v3.jsonb_document_contains`, * consolidating the last `ste_vec_*`-named public object into the `jsonb_*` - * family. The operators are unchanged; only callers that invoke the function - * by name (Supabase / PostgREST) are affected. + * family. Nothing breaks: the operators are unchanged, the PostgREST-facing + * `jsonb_contains` / `jsonb_contained_by` are unchanged, and the old name ships + * on as a deprecated delegating alias for both overloads. * * This is a separate invariant-only edge from the v3 baseline. A database * that already recorded the baseline (and/or 3.0.2 / 3.0.4) invariant must @@ -76,9 +77,10 @@ export default class M extends Migration { sql: "SELECT to_regtype('eql_v3.query_json') IS NOT NULL", }, { - // The rename this release carries: the old `ste_vec_contains` - // name is gone, so assert the new one is what the reinstall - // left behind. + // The rename this release carries. Asserts the NEW name exists, + // which is what distinguishes a 3.0.5 bundle from a 3.0.4 one — + // deliberately not "the old name is absent", since 3.0.5 keeps it + // as a deprecated alias and both names are present after this. description: 'verify the renamed eql_v3.jsonb_document_contains function exists', sql: "SELECT EXISTS (SELECT 1 FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'eql_v3' AND p.proname = 'jsonb_document_contains')", diff --git a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json index 75c24c890..cc6bd650c 100644 --- a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json +++ b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json @@ -11,7 +11,7 @@ "execute": [ { "description": "Upgrade EQL v3 bundle to eql-3.0.5", - "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" + "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--! access is strictly opt-in. A deployment that exposes EQL to\n--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--! the functions it needs. This is intentional least-privilege, not an\n--! oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--! part of the public API and normally needs no grant; where a caller\n--! reaches an internal object indirectly (a public operator/aggregate\n--! whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--! support/constructor/comparator functions, the unsupported-operator\n--! blockers (which only raise), the aggregate state functions, and the\n--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--! internal index-term TYPES do not clutter the Supabase Table Builder\n--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--! here — they are public in `eql_v3` so every operator has a callable\n--! function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n 'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n RETURNS name[]\n LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--! SELECT count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--! SELECT email, count(*) -- email is not in GROUP BY\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--! -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--! -- an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--! SELECT eql_v3.grouped_value(email) AS email, count(*)\n--! FROM users\n--! GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--! SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--! FROM users\n--! ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--! generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--! a single aggregate over `jsonb` accepts them all and returns the value\n--! unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--! eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--! is not deterministic under parallel aggregation. That is exactly what is\n--! wanted for the group-by-eq_term case (every value in a group is an\n--! encryption of the same plaintext, so any one represents the group) and it\n--! matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--! count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n sfunc = eql_v3_internal.grouped_value_sfunc,\n stype = jsonb,\n combinefunc = eql_v3_internal.grouped_value_sfunc,\n parallel = safe\n);\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--! both reached exclusively from plpgsql and btree operator-class support\n--! contexts, where SQL functions can NEVER be inlined and instead pay the\n--! per-call SQL-function executor (measured 3.5x the per-call cost of the\n--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--! caches its plan across calls. The non-array guard preserves the v3\n--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--! so the divergence stays unreachable in practice; JSON null and empty\n--! array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n IMMUTABLE\nAS $$\nDECLARE\n result bytea[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(decode(value::text, 'hex')::bytea)\n INTO result\n FROM jsonb_array_elements_text(val) AS value;\n RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n pgcrypto_schema name;\nBEGIN\n IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n END IF;\n\n SELECT n.nspname INTO pgcrypto_schema\n FROM pg_extension e\n JOIN pg_namespace n ON n.oid = e.extnamespace\n WHERE e.extname = 'pgcrypto';\n\n IF pgcrypto_schema = 'extensions' THEN\n -- expected location, nothing to say\n NULL;\n ELSIF pgcrypto_schema = 'public' THEN\n RAISE NOTICE\n 'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n 'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n ELSE\n RAISE EXCEPTION\n 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n 'runtime. Relocate the extension before installing EQL: '\n 'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n pgcrypto_schema;\n END IF;\nEND $$;\n\n--! @file v3/json/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}).\n--! - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--! and — for an ordered (number/string) path entry only — a string\n--! `op` ordering term. Value entries (value-inclusive selectors) and\n--! non-orderable path entries (bool/null/object/array) are term-less\n--! `{s, c}`: exact matching is selector presence, so an entry carries\n--! no per-value equality term. `hm` is retired and must be absent —\n--! a stale `hm`-bearing payload fails loudly rather than degrading to\n--! a value-less entry. The optional document metadata `i`, `v`, and\n--! `h` is accepted because selector lookup grafts it onto the entry\n--! before casting to `public.eql_v3_json_entry`.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 's') = 'string'\n AND jsonb_typeof(val -> 'c') = 'string'\n AND NOT (val ? 'hm')\n AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--! a string `s`, no ciphertext, an optional string `op` (present only\n--! on ordered path entries), and no `hm`. A containment needle is a\n--! set of selectors — a value-selector's presence in the stored\n--! document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--! eql_v3.query_json domain CHECK, where a SQL function can never be\n--! inlined (and the CHECK itself cannot absorb this body — it needs a\n--! subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--! caches its plan across calls instead of paying the per-call SQL-function\n--! executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n RETURNS boolean\n LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n RETURN COALESCE(\n jsonb_typeof(val) = 'object'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - 'sv' = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT COALESCE((\n jsonb_typeof(elem) = 'object'\n AND jsonb_typeof(elem -> 's') = 'string'\n AND NOT (elem ? 'c')\n AND NOT (elem ? 'hm')\n AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\n ), false)\n ),\n false\n );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--! `v = 3`, `i`, a string key header `h`, an `sv` array, and valid\n--! sv entry elements. `h` carries the document's key-retrieval\n--! material once (every entry encrypts under the document's single\n--! data key; entry `c` values are raw AEAD output whose nonces are\n--! derived from the entries' selectors) — it is opaque to SQL and\n--! only ever carried/grafted, never parsed. Unknown envelope keys are\n--! rejected; `k` and `a` remain optional compatibility fields.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT COALESCE(\n jsonb_typeof(val) = 'object'\n AND val ? 'v'\n AND val ->> 'v' = '3'\n AND val ? 'i'\n AND jsonb_typeof(val -> 'h') = 'string'\n AND jsonb_typeof(val -> 'sv') = 'array'\n AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\n AND NOT EXISTS (\n SELECT 1\n FROM jsonb_array_elements(\n CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n ) AS elem\n WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n ),\n false\n )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--! `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_search AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json_entry AS jsonb\n CHECK (\n VALUE IS NULL\n OR COALESCE(\n jsonb_typeof(VALUE) = 'object'\n AND jsonb_typeof(VALUE -> 's') = 'string'\n AND jsonb_typeof(VALUE -> 'c') = 'string'\n AND NOT (VALUE ? 'hm')\n AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n false\n )\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--! `'{\"sv\":[{\"s\":\"\"}]}'::eql_v3.query_json`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_json_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_json`).\n--! @endinternal\nDO $$\nBEGIN\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_json AS jsonb\n CHECK (\n public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(\n jsonb_strip_nulls(\n jsonb_build_object(\n 's', elem -> 's'\n )\n )\n )\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n RETURNS eql_v3.query_json\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT jsonb_build_object(\n 'sv',\n coalesce(\n (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n '[]'::jsonb\n )\n )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n AS ASSIGNMENT;\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--! index expressions)\n--! * No `SET` clauses (e.g. `SET search_path = ...`)\n--! * Not `SECURITY DEFINER`\n--! * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--! `error` — fixable, blocks index matching, ship-blocking.\n--! `warning` — likely-fixable, may not block matching but signals intent.\n--! `info` — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--! `inlinability_language` — implementation function isn't `LANGUAGE sql`.\n--! `inlinability_volatility` — implementation function is VOLATILE.\n--! `inlinability_set_clause` — implementation function has a `SET` clause.\n--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`.\n--! `inlinability_transitive` — implementation function is itself inlinable\n--! but its body invokes a non-inlinable function\n--! (depth 1; the planner can't peek through\n--! that boundary).\n--! `blocker_language` — encrypted-domain blocker is not LANGUAGE\n--! plpgsql. The planner can inline / elide a\n--! LANGUAGE sql body when the result is\n--! provably unused, silently bypassing the\n--! RAISE that the blocker exists to perform.\n--! `blocker_strict` — encrypted-domain blocker is STRICT.\n--! PostgreSQL skips the body and returns NULL\n--! on NULL arguments, silently bypassing the\n--! RAISE.\n--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from\n--! another encrypted domain rather than jsonb.\n--! Operators resolve against the ultimate base\n--! type, so the derived domain does not\n--! inherit the base domain's blocker surface.\n--! `domain_opclass` — an operator class is declared FOR TYPE on an\n--! `eql_v3` encrypted domain. Opclasses on\n--! domains bypass operator resolution; use a\n--! functional index on the extractor instead.\n--! `schema_placement` — a naked composite or enum TYPE lives in the\n--! public `eql_v3` schema. Internal index-term\n--! types (e.g. `ore_block_256_term`) belong in\n--! `eql_v3_internal`; a composite/enum in\n--! `eql_v3` clutters the Supabase Table Builder\n--! type picker, which the schema split exists to\n--! prevent. Move it to `eql_v3_internal`.\n--!\n--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--! FROM eql_v3.lints()\n--! WHERE severity = 'error'\n--! ORDER BY category, object_name;\n--! @endcode\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n severity text,\n category text,\n object_name text,\n message text\n)\nLANGUAGE sql STABLE\nAS $$\n WITH\n -- User-column encrypted domains now live in public so application tables\n -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n -- types whose blockers/operator surfaces the lint must understand.\n encrypted_domain_types AS (\n SELECT\n dt.oid AS typid\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND bt.typname = 'jsonb'\n AND bn.nspname = 'pg_catalog'\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n ),\n\n -- All operators where at least one operand is an EQL-owned type or a public\n -- encrypted domain. Limits the scope of the lint to the operator surface\n -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n eql_operators AS (\n SELECT\n op.oid AS oprid,\n op.oprname AS opname,\n op.oprcode AS implfunc,\n op.oprleft::regtype AS lhs,\n op.oprright::regtype AS rhs,\n op.oprcode::regprocedure AS impl_signature\n FROM pg_operator op\n WHERE EXISTS (\n SELECT 1 FROM pg_type t\n WHERE t.oid IN (op.oprleft, op.oprright)\n AND (\n t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n )\n )\n ),\n\n -- Cross-join with each operator's implementation function metadata.\n -- One row per operator; columns describe the inlinability of the impl.\n op_impl AS (\n SELECT\n eo.opname,\n eo.lhs,\n eo.rhs,\n eo.implfunc AS impl_oid,\n eo.impl_signature::text AS impl_signature,\n lang_l.lanname AS lang,\n p.provolatile AS volatility,\n p.proconfig AS config,\n p.prosecdef AS secdef,\n p.prosrc AS body\n FROM eql_operators eo\n JOIN pg_proc p ON p.oid = eo.implfunc\n JOIN pg_language lang_l ON lang_l.oid = p.prolang\n ),\n\n -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n -- a blocker marker emitted by the codegen (any of the\n -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n -- literal `is not supported for` for older path-operator blockers) AND\n -- that take at least one encrypted domain over jsonb argument. The argument\n -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n -- helpers themselves, which contain the marker in their body but are not\n -- blockers (they take text arguments, not a domain).\n encrypted_domain_blockers AS (\n SELECT\n p.oid AS oid,\n p.oid::regprocedure::text AS signature,\n lang_l.lanname AS lang,\n p.proisstrict AS isstrict\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n OR p.prosrc LIKE '%is not supported for%')\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n )\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Direct inlinability checks: each row examines one operator's │\n -- │ implementation function and emits a violation if any rule is │\n -- │ broken. Multiple violations on the same function become │\n -- │ multiple rows (developers see every reason it doesn't inline). │\n -- └─────────────────────────────────────────────────────────────────┘\n\n SELECT\n 'error' AS severity,\n 'inlinability_language' AS category,\n format('operator %s(%s, %s) -> %s',\n opname, lhs, rhs, impl_signature) AS object_name,\n format(\n 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.',\n lang, opname) AS message\n FROM op_impl\n WHERE lang <> 'sql'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_volatility',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).',\n opname)\n FROM op_impl\n WHERE volatility = 'v'\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_set_clause',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n format(\n 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.')\n FROM op_impl\n WHERE config IS NOT NULL\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_secdef',\n format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n FROM op_impl\n WHERE secdef\n AND NOT EXISTS (\n SELECT 1 FROM encrypted_domain_blockers b\n WHERE b.oid = op_impl.impl_oid\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Transitive inlinability: an operator implementation function │\n -- │ that's itself inlinable can still fail to inline if its body │\n -- │ calls a non-inlinable function. Walk one level via pg_depend. │\n -- │ │\n -- │ Postgres records function-to-function dependencies in │\n -- │ pg_depend with deptype 'n' (normal) when one function references│\n -- │ another in its body — but only at CREATE time and only for │\n -- │ direct calls. This is good enough for v1; deeper transitive │\n -- │ analysis is a follow-up. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'inlinability_transitive',\n format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n oi.impl_signature),\n format(\n 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.',\n called.proname,\n called_lang.lanname,\n CASE called.provolatile\n WHEN 'i' THEN 'IMMUTABLE'\n WHEN 's' THEN 'STABLE'\n WHEN 'v' THEN 'VOLATILE'\n END,\n CASE WHEN called.proconfig IS NOT NULL\n THEN ', has SET clause'\n ELSE '' END)\n FROM op_impl oi\n -- Only worth the transitive check if the outer function is otherwise\n -- inlinable — otherwise the direct lints above already report it.\n JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n JOIN pg_depend d\n ON d.classid = 'pg_proc'::regclass\n AND d.objid = outer_p.oid\n AND d.refclassid = 'pg_proc'::regclass\n AND d.deptype = 'n'\n JOIN pg_proc called ON called.oid = d.refobjid\n JOIN pg_language called_lang ON called_lang.oid = called.prolang\n WHERE oi.lang = 'sql'\n AND oi.volatility IN ('i', 's')\n AND oi.config IS NULL\n AND NOT oi.secdef\n AND called.oid <> outer_p.oid\n AND (\n called_lang.lanname <> 'sql'\n OR called.provolatile = 'v'\n OR called.proconfig IS NOT NULL\n OR called.prosecdef\n )\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │\n -- │ have inverted inlinability requirements vs operator impls. │\n -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │\n -- │ blocker returns NULL on NULL args. Both silently re-enable │\n -- │ operators the storage variant is supposed to block. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_language',\n format('function %s', signature),\n format(\n 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.',\n lang)\n FROM encrypted_domain_blockers\n WHERE lang <> 'plpgsql'\n\n UNION ALL\n\n SELECT\n 'error',\n 'blocker_strict',\n format('function %s', signature),\n 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n FROM encrypted_domain_blockers\n WHERE isstrict\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain identity: an encrypted-domain must be defined directly │\n -- │ over jsonb. Operators resolve against the ultimate base type, │\n -- │ so domain-over-domain inherits jsonb's operator surface and not │\n -- │ the base domain's blockers. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_over_domain',\n format('domain %I.%I', dn.nspname, dt.typname),\n format(\n 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.',\n dn.nspname, dt.typname, bn.nspname, bt.typname)\n FROM pg_catalog.pg_type dt\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n WHERE dt.typtype = 'd'\n AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n AND bt.typtype = 'd'\n AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Domain opclass: an operator class declared FOR TYPE on an │\n -- │ encrypted-domain bypasses operator resolution at index time. │\n -- │ Use a functional index on the extractor instead. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'domain_opclass',\n format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n format(\n 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.',\n cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n FROM pg_catalog.pg_opclass oc\n JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n -- ┌─────────────────────────────────────────────────────────────────┐\n -- │ Schema placement: the public `eql_v3` schema must hold only the │\n -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n -- │ there is an internal index-term type in the wrong schema — it │\n -- │ clutters the Supabase type picker the split exists to keep clean. │\n -- └─────────────────────────────────────────────────────────────────┘\n\n UNION ALL\n\n SELECT\n 'error',\n 'schema_placement',\n format('type %I.%I', n.nspname, t.typname),\n format(\n 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.',\n n.nspname, t.typname,\n CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'eql_v3'\n AND t.typtype IN ('c', 'e')\n\n ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n 'EQL lint: returns one row per non-inlinable operator implementation. '\n 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n 'CI-gateable check that all operator implementations on eql_v3 types are '\n 'eligible for planner inlining.';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_bigint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_boolean.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_boolean AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_date.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_date_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_double.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_double_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars//.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--! for TYPE' so unsupported domain operators surface a clear\n--! error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! native operators whose result is jsonb (#>, -, #-, ||), so composed\n--! expressions resolve and the body raises rather than failing earlier\n--! with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--! encrypted_domain_unsupported_bool but typed for blockers shadowing\n--! the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--! cannot express exact equality. It is explicitly claimed to prevent\n--! PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_search\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n LEFTARG = public.eql_v3_json_search,\n RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n LEFTARG = jsonb,\n RIGHTARG = public.eql_v3_json_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_integer.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_integer_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_json.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_json AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_numeric.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_real.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_real_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_smallint.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)';\n\n --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_text.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_text_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n --! @brief Encrypted domain public.eql_v3_text_match.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_match AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_text_search_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'ob'\n AND VALUE ? 'bf'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)';\n\n --! @brief Encrypted domain public.eql_v3_text_search.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_text_search AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE ? 'op'\n AND VALUE ? 'bf'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--! never valid column types, so they don't belong in the column-type\n--! namespace, and dropping the EQL-owned schema can never drop an\n--! application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--! uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--! operator overloads and will not resolve.\n\nDO $$\nBEGIN\n --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'hm'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'ob'\n AND NOT (VALUE ? 'c')\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n ) THEN\n CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'op'\n AND NOT (VALUE ? 'c')\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n --! @brief Encrypted domain public.eql_v3_timestamp.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'hm'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'ob'\n AND jsonb_typeof(VALUE -> 'ob') = 'array'\n AND jsonb_array_length(VALUE -> 'ob') > 0\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n IF NOT EXISTS (\n SELECT 1 FROM pg_type\n WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n ) THEN\n CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n CHECK (\n jsonb_typeof(VALUE) = 'object'\n AND VALUE ? 'v'\n AND VALUE ? 'i'\n AND VALUE ? 'c'\n AND VALUE ? 'op'\n AND VALUE->>'v' = '3'\n );\n END IF;\n\n COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--! n-gram token match, not containment. `@>`/`<@` on the text match\n--! domains now raise. Internally the `@@` wrapper still reduces to the base\n--! type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--! NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n RETURNS eql_v3_internal.bloom_filter\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n RETURNS eql_v3_internal.hmac_256\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n RETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope`\n--! domains); the domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--! absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/json/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--! eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n RETURNS jsonb\n IMMUTABLE STRICT PARALLEL SAFE\n LANGUAGE SQL\nAS $$\n SELECT jsonb_strip_nulls(\n jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--! decryptable on its own: the decryption unit is the entry — its `s`\n--! (nonce source), `c`, and the document key header `h` (grafted onto\n--! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--! `c` remains a self-describing encrypted record.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'c' THEN\n RETURN val->>'c';\n END IF;\n RAISE 'Expected a ciphertext (c) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 's' THEN\n RETURN val->>'s';\n END IF;\n RAISE 'Expected a selector index (s) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--! guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--! eql_v3.ord_term for ordered comparisons. This term is not an\n--! exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n RETURNS bytea\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--! `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry)\n RETURNS eql_v3_internal.ope_cllw\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n RETURNS jsonb[]\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb;\n ary jsonb[];\n BEGIN\n IF val ? 'sv' THEN\n sv := val->'sv';\n ELSE\n sv := jsonb_build_array(val);\n END IF;\n\n SELECT array_agg(elem)\n INTO ary\n FROM jsonb_array_elements(sv) AS elem;\n\n RETURN ary;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n IF val ? 'a' THEN\n RETURN (val->>'a')::boolean;\n END IF;\n RETURN false;\n END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic containment fields (s) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT ARRAY(\n SELECT jsonb_object_agg(kv.key, kv.value)\n FROM jsonb_array_elements(\n CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n ) AS elem,\n LATERAL jsonb_each(elem) AS kv(key, value)\n WHERE kv.key = 's'\n GROUP BY elem\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--! deterministic fields — the function-form entrypoint for containment on\n--! platforms without operator support (Supabase/PostgREST). The typed\n--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to\n--! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a\n--! parity test pins this). Also the documented GIN index expression\n--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--! entrypoint for `<@` on platforms without operator support. The typed\n--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead,\n--! but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = **selector equal**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_contains(a jsonb[], b jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n result boolean;\n _a jsonb;\n BEGIN\n result := false;\n\n FOR idx IN 1..array_length(a, 1) LOOP\n _a := a[idx];\n result := result OR (eql_v3.selector(_a) = eql_v3.selector(b));\n EXIT WHEN result;\n END LOOP;\n\n RETURN result;\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n 'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_json_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n RETURNS SETOF public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT EXISTS (\n SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry\n FROM jsonb_array_elements(val -> 'sv') elem\n WHERE elem ->> 's' = selector\n LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n RETURNS integer\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n BEGIN\n IF eql_v3_internal.is_ste_vec_array(val) THEN\n sv := eql_v3.ste_vec(val);\n RETURN array_length(sv, 1);\n END IF;\n\n RAISE 'cannot get array length of a non-array';\n END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n RETURNS SETOF public.eql_v3_json_entry\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n sv jsonb[];\n meta jsonb;\n item jsonb;\n BEGIN\n IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n RAISE 'cannot extract elements from non-array';\n END IF;\n\n meta := eql_v3.meta_data(val);\n sv := eql_v3.ste_vec(val);\n\n FOR idx IN 1..array_length(sv, 1) LOOP\n item = sv[idx];\n RETURN NEXT (meta || item)::public.eql_v3_json_entry;\n END LOOP;\n\n RETURN;\n END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--! therefore IGNORE `op`-less entries (they never become or survive as the\n--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--! `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--! `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--! row is `op`-less. An all-`op`-less input has no orderable extremum and\n--! returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly greater.\n IF state_ope IS NULL OR value_ope < state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_json_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n state public.eql_v3_json_entry,\n value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n -- A non-orderable (op-less) candidate never replaces the running extremum.\n IF value_ope IS NULL THEN\n RETURN state;\n END IF;\n -- Adopt the candidate when the running extremum is itself non-orderable\n -- (e.g. an op-less STRICT seed) or strictly lesser.\n IF state_ope IS NULL OR value_ope > state_ope THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n stype = public.eql_v3_json_entry,\n combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--! operator and silently returns native jsonb semantics (a root-key lookup,\n--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search`\n--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--! native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--! the domain type-kind and applies to the native-jsonb blockers too. See\n--! the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT (\n eql_v3.meta_data(e) ||\n jsonb_path_query_first(\n e,\n '$.sv[*] ? (@.s == $sel)'::jsonpath,\n jsonb_build_object('sel', selector)\n )\n )::public.eql_v3_json_entry\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n RETURNS public.eql_v3_json_entry\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT CASE\n WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to\n -- its base type and binds native `jsonb -> text` (see the @warning above) —\n -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare\n -- untyped literal. The cast documents that intent and guards the `-> selector`\n -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)`\n -- operator instead of native array access.\n (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n ELSE NULL\n END\n$$;\n\nCREATE OPERATOR ->(\n FUNCTION=eql_v3.\"->\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--! text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json_search Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector text)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--! ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json_search, selector integer)\n RETURNS text\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n FUNCTION=eql_v3.\"->>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(a)::jsonb\n @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n FUNCTION=eql_v3.\"@>\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.to_ste_vec_query(b)::jsonb\n @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=public.eql_v3_json_search,\n RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n FUNCTION=eql_v3.\"<@\",\n LEFTARG=eql_v3.query_json,\n RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--! Comparing its deterministic `op` bytes would be lossy for\n--! `bigint`/`numeric`/`text`; exact equality is document containment on a\n--! value-selector needle. This blocker is deliberately non-STRICT so a\n--! NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >,\n NEGATOR = >=,\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=,\n NEGATOR = >,\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <,\n NEGATOR = <=,\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n RETURNS boolean\n LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry,\n RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=,\n NEGATOR = <,\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3_internal.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3_internal.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3_internal.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3_internal.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3_internal.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3_internal.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ope,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--! from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--! SQL-function executor on every compared value in the opclass hot path\n--! (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--! non-array guard preserves the v3 behaviour (returns NULL for a\n--! non-array scalar; the v2 plpgsql original raised); the caller only\n--! reaches this when `has_ore_block_256(val)` is true, which requires\n--! `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--! An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--! NULL terms make the comparator return NULL (so an empty-text row silently\n--! drops out of ordered queries). An empty array instead engages the\n--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--! non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n IMMUTABLE\nAS $$\nDECLARE\n terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n RETURN NULL;\n END IF;\n SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n INTO terms\n FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n -- plpgsql pitfall: `SELECT INTO ` assigns the\n -- select-list columns FIELD-WISE into the variable — return the row\n -- constructor directly instead. The COALESCE stays load-bearing for the\n -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n -- the comparator needs an EMPTY terms array, not NULL terms.\n RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n RETURNS eql_v3_internal.ore_block_256\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n -- entering the body, so no explicit `val IS NULL` guard is needed.\n IF eql_v3_internal.has_ore_block_256(val) THEN\n RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n END IF;\n RAISE 'Expected an ore index (ob) value in json: %', val;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--! this guard treats a present-but-non-array `ob` (a scalar or object) as\n--! absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--! structurally invalid `ob` payload at the boundary instead of silently\n--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--! reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--! both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n RETURNS boolean\n IMMUTABLE STRICT PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--! overloads all are). This deliberately diverges from the v2 originals,\n--! which carry no volatility marker and so default to `VOLATILE`. The\n--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--! planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--! the NULL-handling branches below are load-bearing for the array overload.\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term)\n RETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n eq boolean := true;\n unequal_block smallint := 0;\n hash_key bytea;\n data_block bytea;\n encrypt_block bytea;\n target_block bytea;\n\n left_block_size CONSTANT smallint := 16;\n right_block_size CONSTANT smallint := 32;\n\n -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n -- Wire format per term:\n -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49\n -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n -- (N=14, 702B) with one comparator.\n n integer;\n left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes)\n right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N)\n\n indicator smallint := 0;\n BEGIN\n IF a IS NULL AND b IS NULL THEN\n RETURN 0;\n END IF;\n\n IF a IS NULL THEN\n RETURN -1;\n END IF;\n\n IF b IS NULL THEN\n RETURN 1;\n END IF;\n\n IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n RAISE EXCEPTION 'Ciphertexts are different lengths';\n END IF;\n\n -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n -- and derives N = 0, which would fall through to the all-blocks-equal path\n -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n END IF;\n\n n := (octet_length(a.bytes) - 16) / 49;\n left_offset := 1 + n; -- left blocks begin right after the N PRP bytes\n right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT\n\n FOR block IN 0..n-1 LOOP\n -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n IF\n substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size)\n THEN\n IF eq THEN\n unequal_block := block;\n END IF;\n eq = false;\n END IF;\n END LOOP;\n\n IF eq THEN\n RETURN 0::integer;\n END IF;\n\n -- Hash key is the IV from the right CT of b.\n hash_key := substr(b.bytes, right_offset + 1, 16);\n\n -- First right block is at right_offset + nonce_size (ordinally indexed).\n target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n indicator := (\n get_bit(\n encrypt_block,\n 0\n ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n IF indicator = 1 THEN\n RETURN 1::integer;\n ELSE\n RETURN -1::integer;\n END IF;\n END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[])\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n DECLARE\n cmp_result integer;\n BEGIN\n IF a IS NULL OR b IS NULL THEN\n RETURN NULL;\n END IF;\n\n IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n RETURN 0;\n END IF;\n\n IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n RETURN -1;\n END IF;\n\n IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n RETURN 1;\n END IF;\n\n cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n IF cmp_result = 0 THEN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n END IF;\n\n RETURN cmp_result;\n END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n IMMUTABLE\n SET search_path = pg_catalog, extensions, public\nAS $$\n BEGIN\n RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n LANGUAGE sql\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal._ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n FUNCTION=eql_v3_internal.ore_block_256_eq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.=),\n NEGATOR = OPERATOR(public.<>),\n RESTRICT = eqsel,\n JOIN = eqjoinsel,\n HASHES,\n MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n FUNCTION=eql_v3_internal.ore_block_256_neq,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<>),\n NEGATOR = OPERATOR(public.=),\n RESTRICT = neqsel,\n JOIN = neqjoinsel,\n MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n FUNCTION=eql_v3_internal.ore_block_256_gt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<),\n NEGATOR = OPERATOR(public.<=),\n RESTRICT = scalargtsel,\n JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n FUNCTION=eql_v3_internal.ore_block_256_lt,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>),\n NEGATOR = OPERATOR(public.>=),\n RESTRICT = scalarltsel,\n JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n FUNCTION=eql_v3_internal.ore_block_256_lte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.>=),\n NEGATOR = OPERATOR(public.>),\n RESTRICT = scalarlesel,\n JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n FUNCTION=eql_v3_internal.ore_block_256_gte,\n LEFTARG=eql_v3_internal.ore_block_256,\n RIGHTARG=eql_v3_internal.ore_block_256,\n COMMUTATOR = OPERATOR(public.<=),\n NEGATOR = OPERATOR(public.<),\n RESTRICT = scalargesel,\n JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_bigint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_date_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_double_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_integer_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_numeric_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_real_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_smallint_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3.matches,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_text_search_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n FUNCTION = eql_v3.eq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n FUNCTION = eql_v3.neq,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n FUNCTION = eql_v3.lt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n FUNCTION = eql_v3.lte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n FUNCTION = eql_v3.gt,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n FUNCTION = eql_v3.gte,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n FUNCTION = eql_v3_internal.contains,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n FUNCTION = eql_v3_internal.contained_by,\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n FUNCTION = eql_v3_internal.\"->\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n FUNCTION = eql_v3_internal.\"->>\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n FUNCTION = eql_v3_internal.\"?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n FUNCTION = eql_v3_internal.\"?|\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n FUNCTION = eql_v3_internal.\"?&\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n FUNCTION = eql_v3_internal.\"@?\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @@ (\n FUNCTION = eql_v3_internal.\"@@\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n FUNCTION = eql_v3_internal.\"#>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n FUNCTION = eql_v3_internal.\"#>>\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n FUNCTION = eql_v3_internal.\"-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n FUNCTION = eql_v3_internal.\"#-\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n FUNCTION = eql_v3_internal.\"||\",\n LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value < state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.min_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.min_sfunc,\n parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n IF value > state THEN\n RETURN value;\n END IF;\n RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n sfunc = eql_v3_internal.max_sfunc,\n stype = public.eql_v3_timestamp_ord_ore,\n combinefunc = eql_v3_internal.max_sfunc,\n parallel = safe\n);\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--! integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--! the installer as a non-superuser role, so the DO block below ATTEMPTS\n--! the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--! letting the single installer run everywhere. When the class is absent,\n--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--! but the order-preserving (OPE) ordering domains — whose extractor\n--! return types carry a native btree opclass — still index without it. On\n--! superuser installs (self-managed Postgres, the SQLx test matrix) the\n--! class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n EXECUTE $ddl$\n CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n OPERATOR 1 public.<,\n OPERATOR 2 public.<=,\n OPERATOR 3 public.=,\n OPERATOR 4 public.>=,\n OPERATOR 5 public.>,\n FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n $ddl$;\n\n RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n WHEN insufficient_privilege THEN\n RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n IF EXISTS (\n SELECT 1\n FROM pg_catalog.pg_opclass c\n JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n WHERE am.amname = 'btree'\n AND c.opcdefault\n AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n ) THEN\n RETURN;\n END IF;\n\n --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n --! without the ORE operator class. Always raises; never returns.\n --! @internal\n CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n RETURNS boolean\n IMMUTABLE PARALLEL SAFE\n SET search_path = pg_catalog, extensions, public\n LANGUAGE plpgsql\n AS $poison$\n BEGIN\n RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n USING HINT = 'Use ' || alternatives || ' instead.',\n ERRCODE = 'feature_not_supported';\n END;\n $poison$;\n -- NOT VALID: skip validating existing stored data (rows written under an\n -- earlier superuser install must stay readable, and re-installing over them\n -- must not abort). Domain coercion still enforces the CHECK on every new\n -- cast/insert regardless of validation status.\n\n ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.5 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n RETURNS text\n IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n SELECT '3.0.5';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.5';\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--! jsonb) and the encrypted-domain family (recognised structurally,\n--! including public user-column domains) are deliberately left\n--! unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n fn_oid oid;\n inline_critical_oids oid[];\n jsonb_oid oid;\nBEGIN\n SELECT t.oid INTO jsonb_oid\n FROM pg_catalog.pg_type t\n JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n IF jsonb_oid IS NULL THEN\n RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n END IF;\n\n -- eql_v3 SEM index-term functions that must stay inlinable for\n -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n -- in the legacy combined pin_search_path.sql.\n SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND (\n (p.pronargs = 2\n AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n 'ore_block_256_lt', 'ore_block_256_lte',\n 'ore_block_256_gt', 'ore_block_256_gte'))\n -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n -- domain over bytea (native comparison operators and btree opclass),\n -- so there are no ope-specific comparison functions to keep inlinable.\n OR (p.pronargs = 1\n AND p.proname = 'ope_cllw'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'hmac_256'\n AND p.proargtypes[0] = jsonb_oid)\n OR (p.pronargs = 1\n AND p.proname = 'bloom_filter'\n AND p.proargtypes[0] = jsonb_oid)\n );\n\n FOR fn_oid IN\n SELECT p.oid\n FROM pg_catalog.pg_proc p\n JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n AND p.prokind IN ('f', 'w')\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n WHERE c LIKE 'search_path=%'\n )\n AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n -- domains live in public; implementation-only domains live in EQL-owned\n -- schemas.\n AND NOT (\n p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n WHERE l.lanname = 'sql')\n AND p.provolatile = 'i'\n AND EXISTS (\n SELECT 1\n FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n WHERE dt.typtype = 'd'\n AND dt.typbasetype = jsonb_oid\n AND (\n dn.nspname = 'public'\n OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n )\n )\n )\n -- Comment-marker fallback for hand-written inline-critical extension\n -- functions that take no domain argument.\n AND NOT EXISTS (\n SELECT 1 FROM pg_catalog.pg_description d\n WHERE d.objoid = p.oid\n AND d.classoid = 'pg_catalog.pg_proc'::regclass\n AND d.description LIKE 'eql-inline-critical%'\n )\n LOOP\n EXECUTE pg_catalog.format(\n 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n fn_oid::regprocedure\n );\n END LOOP;\nEND $$;\n" } ], "postcheck": [ diff --git a/packages/stack-prisma/test/v3/migration-v3.test.ts b/packages/stack-prisma/test/v3/migration-v3.test.ts index cd8b63d43..e495201f0 100644 --- a/packages/stack-prisma/test/v3/migration-v3.test.ts +++ b/packages/stack-prisma/test/v3/migration-v3.test.ts @@ -117,18 +117,18 @@ const PUBLISHED_MIGRATIONS = [ // pinned release rather than a historical one, which is why the // lockstep test below has something to match. migrationHash: - 'sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05', + 'sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313', installSqlSha256: - '7ad9c9f884083979c1cf483ff4f68d2569257d6c6fab15d9e4586f4c93703cad', + 'accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048', }, { dirName: CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME, metadata: v3Upgrade305Metadata, ops: v3Upgrade305Ops, migrationHash: - 'sha256:7bafd9d6c5d244332ff0b0943604dbd026c8369e24d2f335b1365c5f78e49d38', + 'sha256:3b2b838bee634f2de4a5e88f1625a45d47c327e3021b0e2ccba36c09a9666178', installSqlSha256: - '7ad9c9f884083979c1cf483ff4f68d2569257d6c6fab15d9e4586f4c93703cad', + 'accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048', }, { dirName: CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME, @@ -418,14 +418,42 @@ describe('v3 baseline migration (20260601T0100_install_eql_v3_bundle)', () => { expect(runtimeUpgrade.ops).toEqual(v3Upgrade305Ops) }) - it('the 3.0.5 upgrade edge carries the renamed jsonb_document_contains', () => { + it('the 3.0.5 upgrade edge carries the rename AND the deprecated aliases', () => { // The behavioural content of this release: `eql_v3.ste_vec_contains` - // became `eql_v3.jsonb_document_contains`. Assert against the baked - // bytes, so an upgrade edge that ships a bundle without the rename - // (the skew this whole lockstep scheme exists to catch) fails here. + // became `eql_v3.jsonb_document_contains`, and the old name was KEPT as + // a deprecated delegating alias. Assert against the baked bytes, so an + // upgrade edge shipping a bundle without the rename — the skew this + // whole lockstep scheme exists to catch — fails here. + // + // This asserted `not.toContain('ste_vec_contains')` until upstream + // 142f41d8 restored both overloads as aliases, which is what makes 3.0.5 + // a genuinely non-breaking patch: the operators never moved, the + // PostgREST-facing `jsonb_contains`/`jsonb_contained_by` never moved, and + // now direct callers of the old name keep working too. Asserting absence + // would now fail against the published bundle — so assert the SHAPE + // instead: exactly two alias definitions, both delegating to the new + // name, and no remaining call site that still routes through the old one. const sql = firstExecuteSql(v3Upgrade305Ops) expect(sql).toContain('eql_v3.jsonb_document_contains') - expect(sql).not.toContain('ste_vec_contains') + + const aliasDefs = sql.match(/CREATE FUNCTION eql_v3\.ste_vec_contains\(/g) + expect(aliasDefs).toHaveLength(2) + + // Delegation, not a second copy of the implementation: every alias body + // is a one-line SELECT through the new name. A duplicated body would + // drift from the real implementation with nothing to catch it. + for (const body of sql.matchAll( + /CREATE FUNCTION eql_v3\.ste_vec_contains\([^)]*\)[\s\S]*?\$\$([\s\S]*?)\$\$/g, + )) { + expect(body[1]).toContain('eql_v3.jsonb_document_contains') + } + + // Both are marked deprecated in the database itself, not only in the + // generated docs — `COMMENT ON FUNCTION` is what a DBA inspecting the + // schema actually sees. + expect( + sql.match(/COMMENT ON FUNCTION eql_v3\.ste_vec_contains\(/g), + ).toHaveLength(2) }) it('pins the head ref at the unchanged hash with all invariants', () => { diff --git a/packages/stack-prisma/test/v3/stale-vendored-space.test.ts b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts new file mode 100644 index 000000000..3243c3b58 --- /dev/null +++ b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts @@ -0,0 +1,629 @@ +/** + * What happens to a consumer who IGNORES the 3.0.5 changeset's "Action + * required" note — i.e. keeps a `migrations/cipherstash/` directory + * generated against `@cipherstash/stack-prisma@1.0.0` and upgrades the + * package underneath it. + * + * The 3.0.5 release re-emitted the published baseline + * (`20260601T0100_install_eql_v3_bundle`): its bytes, and so its + * `migrationHash`, changed from `sha256:fc495f7f…` to `sha256:23c98b03…`. + * These artefacts are content-addressed and normally append-only, so a + * re-emit is the one case the machinery was never designed for. The + * changeset tells consumers to delete the vendored directory and re-run + * `prisma-next migration plan`. That instruction is prose in a changelog: + * this suite pins what actually happens when it is not followed. + * + * The mechanism, established by reading the framework (no live database + * is involved in any of it): + * + * - `migrationHash` is computed over a package's OWN bytes + * (`verifyMigrationHash`), so a stale-but-intact vendored baseline is + * SELF-CONSISTENT and passes every integrity check. Nothing anywhere + * compares an on-disk package against the descriptor's shipped one. + * - The CLI seed phase (`migration plan`) materialises descriptor + * packages with `materialiseExtensionMigrationPackageIfMissing` — a + * by-existence skip. The stale baseline is silently retained; only the + * new 3.0.5 directory is written. `refs/head.json` IS overwritten. + * - `db init` / `db update` / `migrate` then plan from the ON-DISK + * graph only (`computeExtensionSpaceApplyPath`); the descriptor is + * never consulted again. + * + * The suite is offline and deterministic — the fixture is reconstructed + * from artefacts already in this repo and proved byte-equivalent to the + * published 1.0.0 baseline by its content hash (see + * `STALE_1_0_0_BASELINE_HASH`). It therefore runs in the normal + * `pnpm --filter @cipherstash/stack-prisma test` suite with no env guard + * and no skip. + */ +import { mkdtemp, readFile, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { fileURLToPath } from 'node:url' +import type { MigrationPlanOperation } from '@prisma-next/framework-components/control' +import { computeMigrationHash } from '@prisma-next/migration-tools/hash' +import { + materialiseExtensionMigrationPackageIfMissing, + readMigrationsDir, + writeMigrationPackage, +} from '@prisma-next/migration-tools/io' +import type { MigrationMetadata } from '@prisma-next/migration-tools/metadata' +import type { MigrationOps } from '@prisma-next/migration-tools/package' +import { + computeExtensionSpaceApplyPath, + emitContractSpaceArtefacts, + spaceMigrationDirectory, +} from '@prisma-next/migration-tools/spaces' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import v3BaselineMetadata from '../../migrations/20260601T0100_install_eql_v3_bundle/migration.json' with { + type: 'json', +} +import headRef from '../../migrations/refs/head.json' with { type: 'json' } +import cipherstashDescriptor from '../../src/exports/control' +import { CIPHERSTASH_SPACE_ID } from '../../src/extension-metadata/constants' +import { + CIPHERSTASH_V3_302_UPGRADE_MIGRATION_NAME, + CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME, + CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME, + CIPHERSTASH_V3_BASELINE_MIGRATION_NAME, + CIPHERSTASH_V3_INVARIANTS, +} from '../../src/extension-metadata/constants-v3' + +/** + * The `migrationHash` `@cipherstash/stack-prisma@1.0.0` published for + * `20260601T0100_install_eql_v3_bundle`, before the 3.0.5 re-emit. It is + * what a consumer's vendored copy still carries. Recorded here as the + * fixture's acceptance criterion, not as live history: the frozen set of + * CURRENT hashes lives in `migration-v3.test.ts`. + */ +const STALE_1_0_0_BASELINE_HASH = + 'sha256:fc495f7f59e6d18ae8e3df594a38898263ca91f8f5fb5f625bff20d04a0d7223' + +/** The three invariants a 1.0.0 install recorded on the marker row. */ +const INVARIANTS_1_0_0 = [ + CIPHERSTASH_V3_INVARIANTS.installBundle, + CIPHERSTASH_V3_INVARIANTS.upgradeBundle302, + CIPHERSTASH_V3_INVARIANTS.upgradeBundle304, +] as const + +/** + * The runner's apply-time policy gate, reproduced. `db init` runs with + * `allowedOperationClasses: ['additive']`; the Postgres target's + * `enforcePolicyCompatibility` refuses the whole run on the first op + * outside that set, naming only the operation id and its class. + * (`migrate` and `db update` allow more classes — `migrate` allows all + * four, which is why the same on-disk state behaves differently there.) + */ +function opsRefusedByDbInitPolicy( + ops: ReadonlyArray<{ readonly id: string; readonly operationClass: string }>, +): readonly string[] { + return ops.filter((op) => op.operationClass !== 'additive').map((op) => op.id) +} + +/** + * The SQL target's op shape. `MigrationPlanOperation` (the framework's + * base type) carries only `id` / `label` / `operationClass` / + * `invariantId`; the `execute` / `postcheck` step lists are added by + * `@prisma-next/target-postgres` and are what this suite reads. Declared + * locally so the single widening cast lives in `asSqlOps` below rather + * than at every use site. + */ +interface SqlMigrationOp extends MigrationPlanOperation { + readonly execute: ReadonlyArray<{ + readonly description: string + readonly sql: string + }> + readonly postcheck: ReadonlyArray<{ + readonly description: string + readonly sql: string + }> +} + +function asSqlOps(ops: MigrationOps): readonly SqlMigrationOp[] { + return ops as readonly SqlMigrationOp[] +} + +function descriptorSpace() { + const space = cipherstashDescriptor.contractSpace + if (!space) throw new Error('descriptor ships no contractSpace') + return space +} + +function descriptorPackage(dirName: string) { + const pkg = descriptorSpace().migrations.find((m) => m.dirName === dirName) + if (!pkg) throw new Error(`descriptor is missing ${dirName}`) + return pkg +} + +/** + * Rebuild the 1.0.0 baseline package from artefacts still in this repo. + * + * Every byte is recoverable without a fixture blob: the 1.0.0 baseline's + * install SQL is the same eql-3.0.4 bundle the `20260728T0000` upgrade + * edge bakes (both pin `installSqlSha256` `63104a81…` — see + * `migration-v3.test.ts`), and the surrounding op shape differs from + * today's baseline only in the release string and the missing 3.0.5 + * carrier op. The reconstruction is *proved* faithful by hashing it: the + * `migrationHash` test below demands `sha256:fc495f7f…`, the value 1.0.0 + * published. Content addressing makes that an exact-bytes assertion, so + * this fixture cannot silently drift into "some old-looking baseline". + */ +function buildStale100Baseline(): { + readonly metadata: MigrationMetadata + readonly ops: readonly SqlMigrationOp[] +} { + const to304 = (text: string): string => text.replaceAll('3.0.5', '3.0.4') + const shipped = asSqlOps( + descriptorPackage(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME).ops, + ) + const install = shipped[0] + const carrier302 = shipped[1] + const carrier304 = shipped[2] + const bundle304 = asSqlOps( + descriptorPackage(CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME).ops, + )[0]?.execute[0]?.sql + if (!install || !carrier302 || !carrier304 || bundle304 === undefined) { + throw new Error('shipped artefacts no longer have the expected op shape') + } + + const ops: readonly SqlMigrationOp[] = [ + { + ...install, + label: to304(install.label), + execute: [ + { + description: to304(install.execute[0]?.description ?? ''), + sql: bundle304, + }, + ], + }, + // The 3.0.2 carrier is byte-identical across 1.0.0 and 3.0.5. + carrier302, + { + ...carrier304, + postcheck: carrier304.postcheck.map((check) => ({ + description: to304(check.description), + sql: to304(check.sql), + })), + }, + ] + + const metadata: MigrationMetadata = { + ...descriptorPackage(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME).metadata, + providedInvariants: [...INVARIANTS_1_0_0], + migrationHash: STALE_1_0_0_BASELINE_HASH, + } + + return { metadata, ops } +} + +/** + * Write a `migrations/cipherstash/` directory exactly as + * `@cipherstash/stack-prisma@1.0.0`'s seed phase would have left it: the + * 1.0.0 baseline, the two upgrade edges 1.0.0 shipped (both unchanged by + * the 3.0.5 release, so the shipped bytes ARE the 1.0.0 bytes), and a + * head ref demanding only the three 1.0.0 invariants. + */ +async function vendorStale100Space(migrationsDir: string): Promise { + const spaceDir = spaceMigrationDirectory(migrationsDir, CIPHERSTASH_SPACE_ID) + const stale = buildStale100Baseline() + + await emitContractSpaceArtefacts(migrationsDir, CIPHERSTASH_SPACE_ID, { + contract: descriptorSpace().contractJson, + contractDts: 'export {};\n', + headRef: { hash: headRef.hash, invariants: [...INVARIANTS_1_0_0] }, + }) + + await writeMigrationPackage( + join(spaceDir, CIPHERSTASH_V3_BASELINE_MIGRATION_NAME), + stale.metadata, + stale.ops, + ) + for (const dirName of [ + CIPHERSTASH_V3_302_UPGRADE_MIGRATION_NAME, + CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME, + ]) { + await materialiseExtensionMigrationPackageIfMissing( + spaceDir, + descriptorPackage(dirName), + ) + } +} + +/** + * The CLI's phase-1 seed, reproduced from its two public primitives — + * `runContractSpaceSeedPhase` itself is not on `@prisma-next/cli`'s + * exports map, and `materialiseExtensionMigrationPackageIfMissing` + * documents this exact mirroring for extension-package tests. Order and + * semantics match `contract-space-seed-phase.ts`: re-emit the framework- + * owned artefacts unconditionally, then materialise only MISSING + * packages. + */ +async function runSeedPhase(migrationsDir: string): Promise { + const space = descriptorSpace() + await emitContractSpaceArtefacts(migrationsDir, CIPHERSTASH_SPACE_ID, { + contract: space.contractJson, + contractDts: 'export {};\n', + headRef: space.headRef, + }) + const spaceDir = spaceMigrationDirectory(migrationsDir, CIPHERSTASH_SPACE_ID) + const written: string[] = [] + for (const pkg of space.migrations) { + const result = await materialiseExtensionMigrationPackageIfMissing( + spaceDir, + pkg, + ) + if (result.written) written.push(pkg.dirName) + } + return written +} + +async function applyPath( + migrationsDir: string, + marker: { + readonly hash: string | null + readonly invariants: readonly string[] + }, +) { + return computeExtensionSpaceApplyPath({ + projectMigrationsDir: migrationsDir, + spaceId: CIPHERSTASH_SPACE_ID, + currentMarkerHash: marker.hash, + currentMarkerInvariants: marker.invariants, + }) +} + +function requireOk( + outcome: T, +): Extract { + if (outcome.kind !== 'ok') { + throw new Error(`expected an applicable path, got "${outcome.kind}"`) + } + return outcome as Extract +} + +let migrationsDir: string +let root: string + +beforeEach(async () => { + root = await mkdtemp(join(tmpdir(), 'cipherstash-stale-vendored-')) + migrationsDir = join(root, 'migrations') +}) + +afterEach(async () => { + await rm(root, { recursive: true, force: true }) +}) + +describe('stale vendored migrations/cipherstash/ (generated against 1.0.0)', () => { + it('the fixture IS the published 1.0.0 baseline — proved by its content hash', () => { + // Content addressing turns this into an exact-bytes claim: only the + // 1.0.0 artefact hashes to fc495f7f…. If this fails, the fixture is + // no longer the thing consumers have on disk and every assertion + // below is about a straw man. + const stale = buildStale100Baseline() + const { migrationHash: _stored, ...envelope } = stale.metadata + expect(computeMigrationHash(envelope, stale.ops)).toBe( + STALE_1_0_0_BASELINE_HASH, + ) + // …and it is genuinely NOT what the package ships today. + expect(v3BaselineMetadata.migrationHash).not.toBe(STALE_1_0_0_BASELINE_HASH) + expect(v3BaselineMetadata.migrationHash).toBe( + 'sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313', + ) + // The stale bundle is 3.0.4: the old name only. Asserted on the STALE + // side alone, deliberately — the shipped 3.0.5 bundle carries BOTH names + // (the new one plus the old restored as a deprecated alias in upstream + // 142f41d8), so `not.toContain('ste_vec_contains')` is false there and + // would be the wrong shape of check. What distinguishes the two artefacts + // is that 3.0.4 has no `jsonb_document_contains` at all. + const staleSql = stale.ops[0]?.execute[0]?.sql ?? '' + expect(staleSql).toContain('ste_vec_contains') + expect(staleSql).not.toContain('jsonb_document_contains') + }) + + it('HEADLINE: the seed phase keeps the stale baseline and reports no problem', async () => { + // This is the finding. `migrationHash` verifies a package against its + // OWN bytes, and the vendored 1.0.0 copy is internally intact — so it + // passes. The seed phase's by-existence skip never rewrites it and + // never compares it to the descriptor. The upgrade is therefore + // silent: no hash mismatch, no warning, no mention of the stale + // directory anywhere in the pipeline. + await vendorStale100Space(migrationsDir) + const newlyWritten = await runSeedPhase(migrationsDir) + + // Only the 3.0.5 directory is new; the re-emitted baseline is NOT + // re-materialised over the stale copy. + expect(newlyWritten).toEqual([CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME]) + + const spaceDir = spaceMigrationDirectory( + migrationsDir, + CIPHERSTASH_SPACE_ID, + ) + const onDiskBaseline = JSON.parse( + await readFile( + join( + spaceDir, + CIPHERSTASH_V3_BASELINE_MIGRATION_NAME, + 'migration.json', + ), + 'utf8', + ), + ) as { migrationHash: string; providedInvariants: string[] } + expect(onDiskBaseline.migrationHash).toBe(STALE_1_0_0_BASELINE_HASH) + expect(onDiskBaseline.providedInvariants).toEqual([...INVARIANTS_1_0_0]) + + // The integrity checker's own load-time verdict: clean. + const { packages, problems } = await readMigrationsDir(spaceDir) + expect(problems).toEqual([]) + expect(packages).toHaveLength(4) + + // …while `refs/head.json` IS overwritten, unconditionally, and now + // demands an invariant the stale genesis edge does not provide. That + // asymmetry (head ref refreshed, packages frozen) is the whole + // failure mode. + const onDiskHead = JSON.parse( + await readFile(join(spaceDir, 'refs', 'head.json'), 'utf8'), + ) as { invariants: string[] } + expect(onDiskHead.invariants).toEqual([...headRef.invariants]) + expect(onDiskHead.invariants).toContain( + CIPHERSTASH_V3_INVARIANTS.upgradeBundle305, + ) + }) + + it('an existing 1.0.0 database still upgrades correctly — only the 3.0.5 edge runs', async () => { + // The changeset's claim: "Your database keeps its markers, so + // already-applied invariants are not re-run — the only new work is + // the 3.0.5 upgrade edge." Verified here for the consumer who did + // NOT delete the directory, which is the strictly harder case. + await vendorStale100Space(migrationsDir) + await runSeedPhase(migrationsDir) + + const outcome = requireOk( + await applyPath(migrationsDir, { + hash: headRef.hash, + invariants: [...INVARIANTS_1_0_0], + }), + ) + expect(outcome.walkedMigrationDirs).toEqual([ + CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME, + ]) + expect(outcome.providedInvariants).toEqual([ + CIPHERSTASH_V3_INVARIANTS.upgradeBundle305, + ]) + // The baseline is NOT re-run, so no marker-recorded invariant is + // re-applied and the stale bundle is never re-installed over 3.0.5. + const ops = asSqlOps(outcome.pathOps) + expect(ops.map((op) => op.id)).toEqual([ + 'cipherstash.upgrade-eql-v3-bundle-3.0.5', + ]) + expect(ops[0]?.execute[0]?.sql).toContain('eql_v3.jsonb_document_contains') + }) + + it('…and identically for a consumer who DID follow the instruction', async () => { + // Deleting `migrations/cipherstash/` and re-running `migration plan` + // regenerates the directory from the descriptor. For an existing + // database the plan is the same single edge — so following the + // instruction costs nothing and changes nothing here. The difference + // only shows up on a fresh database (next two tests). + await runSeedPhase(migrationsDir) + const outcome = requireOk( + await applyPath(migrationsDir, { + hash: headRef.hash, + invariants: [...INVARIANTS_1_0_0], + }), + ) + expect(outcome.walkedMigrationDirs).toEqual([ + CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME, + ]) + }) + + it('an already-3.0.5 database is a no-op — the upgrade edge does not re-run', async () => { + await runSeedPhase(migrationsDir) + const outcome = requireOk( + await applyPath(migrationsDir, { + hash: headRef.hash, + invariants: [...headRef.invariants], + }), + ) + expect(outcome.walkedMigrationDirs).toEqual([]) + expect(outcome.pathOps).toEqual([]) + }) +}) + +describe('fresh database: both install paths must converge on eql-3.0.5', () => { + it('a clean vendored space installs 3.0.5 from the genesis edge alone', async () => { + await runSeedPhase(migrationsDir) + const outcome = requireOk( + await applyPath(migrationsDir, { hash: null, invariants: [] }), + ) + expect(outcome.walkedMigrationDirs).toEqual([ + CIPHERSTASH_V3_BASELINE_MIGRATION_NAME, + ]) + expect(outcome.providedInvariants).toEqual([...headRef.invariants].sort()) + + const ops = asSqlOps(outcome.pathOps) + expect(ops[0]?.execute[0]?.sql).toContain('eql_v3.jsonb_document_contains') + // Every op additive, so `db init`'s additive-only policy accepts it. + expect(opsRefusedByDbInitPolicy(ops)).toEqual([]) + }) + + it('a STALE vendored space still converges on 3.0.5 under `migrate` — but installs the bundle twice', async () => { + // `prisma-next migrate` allows every operation class, so it can walk + // the data-classed 3.0.5 self-edge. The end state is correct; the + // cost is that the stale genesis edge installs eql-3.0.4 first and + // the upgrade edge immediately re-installs eql-3.0.5 over it (the + // bundle SQL is re-install-safe, which is what makes this survivable + // rather than broken). + await vendorStale100Space(migrationsDir) + await runSeedPhase(migrationsDir) + + const outcome = requireOk( + await applyPath(migrationsDir, { hash: null, invariants: [] }), + ) + expect(outcome.walkedMigrationDirs).toEqual([ + CIPHERSTASH_V3_BASELINE_MIGRATION_NAME, + CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME, + ]) + expect(outcome.providedInvariants).toEqual([...headRef.invariants].sort()) + + const ops = asSqlOps(outcome.pathOps) + const bundleSql = ops + .flatMap((op) => op.execute.map((step) => step.sql)) + .filter((sql) => sql.length > 0) + expect(bundleSql).toHaveLength(2) + expect(bundleSql[0]).toContain('ste_vec_contains') + expect(bundleSql[1]).toContain('eql_v3.jsonb_document_contains') + }) + + it('DEFECT: a STALE vendored space breaks `db init`, and the refusal never names the stale directory', async () => { + // `db init` runs additive-only. The stale genesis edge provides three + // of the four head-ref invariants, so the planner has to reach for the + // data-classed 3.0.5 self-edge — and the runner then refuses the run + // with a POLICY_VIOLATION naming only an operation id. + // + // Pinned because it is the one path where ignoring the changeset's + // "Action required" note actually fails, and because the message a + // consumer sees is UNRELATED to the cause: nothing in it mentions the + // vendored directory, the baseline re-emit, or the remedy. There is + // no in-package lever to improve it — the text is produced by + // `@prisma-next/target-postgres`'s `enforcePolicyCompatibility`, and + // the operation id it interpolates is frozen inside a published, + // content-addressed artefact. If this test starts failing because a + // framework upgrade made the refusal self-describing, delete it. + await vendorStale100Space(migrationsDir) + await runSeedPhase(migrationsDir) + + const outcome = requireOk( + await applyPath(migrationsDir, { hash: null, invariants: [] }), + ) + const ops = asSqlOps(outcome.pathOps) + expect(opsRefusedByDbInitPolicy(ops)).toEqual([ + 'cipherstash.upgrade-eql-v3-bundle-3.0.5', + ]) + + // The exact refusal the user reads, reconstructed from the target's + // template. It names an op id and a class; it does not name the + // problem or the remedy. + const refused = ops.find((op) => op.operationClass !== 'additive') + const message = `Operation ${refused?.id} has class "${refused?.operationClass}" which is not allowed by policy.` + expect(message).toBe( + 'Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is not allowed by policy.', + ) + expect(message).not.toContain('migrations/cipherstash') + expect(message).not.toContain('migration plan') + + // Since the message cannot be improved from inside this package, the + // SHIPPED DOCS have to carry the bridge from that exact string to the + // remedy. Pinned so they cannot drift apart: a user's only route from the + // error to the fix is pasting it into a search. + // + // BOTH of them, and the skill is the one that was missed. The README ships + // in the npm tarball and is read by a human who hit the error. `skills/` + // ships inside the `stash` tarball and `installSkills()` copies it into the + // user's `.claude/skills/` — so it is what an AGENT reads, and an agent + // driving `db init` in a repo upgraded from 1.0.0 hits this refusal with no + // route out of it. Nothing type-checks either file; this assertion is the + // only thing holding the pair to the planner's real message. + // `test/v3` -> `test` -> `packages/stack-prisma` -> `packages` -> root. + const repoRoot = join( + dirname(fileURLToPath(import.meta.url)), + '..', + '..', + '..', + '..', + ) + const shipped = { + 'packages/stack-prisma/README.md': await readFile( + join(repoRoot, 'packages/stack-prisma/README.md'), + 'utf8', + ), + 'skills/stash-prisma/SKILL.md': await readFile( + join(repoRoot, 'skills/stash-prisma/SKILL.md'), + 'utf8', + ), + } + for (const [file, body] of Object.entries(shipped)) { + expect(body, `${file} does not name the refusal`).toContain(message) + expect(body, `${file} does not carry the remedy`).toContain( + 'rm -rf migrations/cipherstash', + ) + expect( + body, + `${file} does not name the command that vendors it`, + ).toContain('prisma-next migration plan') + } + }) + + it('the same fresh `db init` succeeds once the instruction is followed', async () => { + // Deleting the directory and re-running the seed phase is the whole + // remedy: the regenerated genesis edge carries all four invariants as + // additive ops, so nothing outside the policy is ever planned. + await vendorStale100Space(migrationsDir) + await rm(spaceMigrationDirectory(migrationsDir, CIPHERSTASH_SPACE_ID), { + recursive: true, + force: true, + }) + await runSeedPhase(migrationsDir) + + const outcome = requireOk( + await applyPath(migrationsDir, { hash: null, invariants: [] }), + ) + const ops = asSqlOps(outcome.pathOps) + expect(opsRefusedByDbInitPolicy(ops)).toEqual([]) + expect(outcome.walkedMigrationDirs).toEqual([ + CIPHERSTASH_V3_BASELINE_MIGRATION_NAME, + ]) + }) +}) + +/** + * The seed phase runs from ONE command. `runContractSpaceSeedPhase` is + * called only by `prisma-next migration plan` + * (`@prisma-next/cli/src/commands/migration-plan.ts`); `migrate`, + * `db init` and `db update` plan straight from whatever is on disk. So a + * consumer who upgrades the package and runs `migrate` — without a + * `migration plan` first — never materialises the 3.0.5 directory and + * never re-pins `refs/head.json`. + * + * This is not specific to the 3.0.5 re-emit (it was equally true of the + * append-only 3.0.2 and 3.0.4 bumps), but it IS the shape the changeset's + * "re-install through this edge on the next `prisma-next migrate`" + * sentence gets wrong, and it is the only path in this whole area that + * fails silently rather than loudly. + */ +describe('no seed phase run: the 3.0.5 upgrade is silently invisible', () => { + it('`migrate` against an existing 1.0.0 database is a no-op — 3.0.5 never applies', async () => { + await vendorStale100Space(migrationsDir) + // deliberately NO runSeedPhase — the user ran `migrate`, not `plan` + + const outcome = requireOk( + await applyPath(migrationsDir, { + hash: headRef.hash, + invariants: [...INVARIANTS_1_0_0], + }), + ) + // No error, no warning, no work: the on-disk head ref still demands + // only the three 1.0.0 invariants, which the marker already has. + expect(outcome.walkedMigrationDirs).toEqual([]) + expect(outcome.pathOps).toEqual([]) + expect(outcome.contractSpaceHeadRef.invariants).not.toContain( + CIPHERSTASH_V3_INVARIANTS.upgradeBundle305, + ) + }) + + it('`db init` against a fresh database silently installs eql-3.0.4', async () => { + await vendorStale100Space(migrationsDir) + // deliberately NO runSeedPhase + + const outcome = requireOk( + await applyPath(migrationsDir, { hash: null, invariants: [] }), + ) + const ops = asSqlOps(outcome.pathOps) + // Succeeds — every op is additive, so `db init`'s policy is happy… + expect(opsRefusedByDbInitPolicy(ops)).toEqual([]) + // …and the database lands on the PREVIOUS bundle, with the marker + // recording three invariants rather than four. + expect(ops[0]?.execute[0]?.sql).toContain('ste_vec_contains') + expect(ops[0]?.execute[0]?.sql).not.toContain('jsonb_document_contains') + expect(outcome.providedInvariants).toEqual([...INVARIANTS_1_0_0].sort()) + }) +}) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 9c5979dfa..50110309a 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -54,12 +54,12 @@ overrides: next@<15.5.18: ~15.5.18 lodash@<4.18.0: ^4.18.0 js-cookie@<3.0.7: ^3.0.7 - postcss@<8.5.10: ^8.5.10 + postcss@<8.5.26: ^8.5.26 vite@>=7.0.0 <7.3.5: ~7.3.5 esbuild@>=0.27.3 <0.28.1: ^0.28.1 - js-yaml@<3.15.0: 3.15.0 - js-yaml@>=4.0.0 <5: 4.2.0 - fast-uri@<3.1.3: 3.1.3 + js-yaml@<3.15.1: 3.15.1 + js-yaml@>=4.0.0 <5: 4.3.1 + fast-uri@<3.1.5: 3.1.5 importers: @@ -75,8 +75,8 @@ importers: specifier: ^22.20.1 version: 22.20.1 js-yaml: - specifier: 4.2.0 - version: 4.2.0 + specifier: 4.3.1 + version: 4.3.1 rimraf: specifier: ^6.1.3 version: 6.1.3 @@ -290,7 +290,7 @@ importers: version: 7.2.0 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) tsx: specifier: catalog:repo version: 4.23.0 @@ -327,7 +327,7 @@ importers: version: 22.20.1 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) typescript: specifier: catalog:repo version: 5.9.3 @@ -355,7 +355,7 @@ importers: version: 8.22.0 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) typescript: specifier: catalog:repo version: 5.9.3 @@ -380,7 +380,7 @@ importers: version: 15.5.21(react-dom@19.2.3(react@19.2.3))(react@19.2.3) tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) typescript: specifier: catalog:repo version: 5.9.3 @@ -516,7 +516,7 @@ importers: version: 3.4.9 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) tsx: specifier: catalog:repo version: 4.23.0 @@ -575,7 +575,7 @@ importers: version: 3.4.9 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) typescript: specifier: catalog:repo version: 5.9.3 @@ -669,7 +669,7 @@ importers: version: 3.4.9 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) typescript: specifier: catalog:repo version: 5.9.3 @@ -715,7 +715,7 @@ importers: version: 3.4.9 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) typescript: specifier: catalog:repo version: 5.9.3 @@ -774,7 +774,7 @@ importers: version: 8.20.0 tsup: specifier: catalog:repo - version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) + version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0) tsx: specifier: catalog:repo version: 4.23.0 @@ -2692,8 +2692,8 @@ packages: fast-string-width@3.0.2: resolution: {integrity: sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==} - fast-uri@3.1.3: - resolution: {integrity: sha512-i70LwGWUduXqzicKXWshooq+sWL1K3WUU5rKZNG/0i3a1OSoX3HqhH5WbWwTmqWfor4urUakGPiRQcleRZTwOg==} + fast-uri@3.1.5: + resolution: {integrity: sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==} fast-wrap-ansi@0.2.0: resolution: {integrity: sha512-rLV8JHxTyhVmFYhBJuMujcrHqOT2cnO5Zxj37qROj23CP39GXubJRBUFF0z8KFK77Uc0SukZUf7JZhsVEQ6n8w==} @@ -2924,12 +2924,12 @@ packages: js-tokens@9.0.1: resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==} - js-yaml@3.15.0: - resolution: {integrity: sha512-ttBQIIQPDeLjpPOohtUdXuXUVoA2uIB6fEH9HyJ7234s5mBJ5wTx20njxplLZQgLaOfpmPQA7X2t5AX6tIPbog==} + js-yaml@3.15.1: + resolution: {integrity: sha512-S99WuO3HlhO3XN41EtYUNl9zzXjoJx7QvmipxsJVxtCBT0YHEFy+iOJhjSvrmV12nYhWpZaM8lPHkJm0yUMbag==} hasBin: true - js-yaml@4.2.0: - resolution: {integrity: sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==} + js-yaml@4.3.1: + resolution: {integrity: sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ==} hasBin: true json-schema-to-ts@3.1.1: @@ -3125,8 +3125,8 @@ packages: resolution: {integrity: sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==} engines: {node: '>=8.0.0'} - nanoid@3.3.12: - resolution: {integrity: sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==} + nanoid@3.3.18: + resolution: {integrity: sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==} engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} hasBin: true @@ -3333,7 +3333,7 @@ packages: engines: {node: '>= 18'} peerDependencies: jiti: '>=1.21.0' - postcss: ^8.5.10 + postcss: ^8.5.26 tsx: ^4.8.1 yaml: ^2.4.2 peerDependenciesMeta: @@ -3346,8 +3346,8 @@ packages: yaml: optional: true - postcss@8.5.14: - resolution: {integrity: sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==} + postcss@8.5.26: + resolution: {integrity: sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==} engines: {node: ^10 || ^12 || >=14} postgres-array@2.0.0: @@ -3706,7 +3706,7 @@ packages: peerDependencies: '@microsoft/api-extractor': ^7.36.0 '@swc/core': ^1 - postcss: ^8.5.10 + postcss: ^8.5.26 typescript: '>=4.5.0' peerDependenciesMeta: '@microsoft/api-extractor': @@ -3957,7 +3957,7 @@ snapshots: dependencies: '@jsdevtools/ono': 7.1.3 '@types/json-schema': 7.0.15 - js-yaml: 4.2.0 + js-yaml: 4.3.1 '@ark/schema@0.56.2': dependencies: @@ -4146,7 +4146,7 @@ snapshots: '@changesets/parse@0.4.3': dependencies: '@changesets/types': 6.1.0 - js-yaml: 4.2.0 + js-yaml: 4.3.1 '@changesets/pre@2.0.2': dependencies: @@ -5259,7 +5259,7 @@ snapshots: ajv@8.20.0: dependencies: fast-deep-equal: 3.1.3 - fast-uri: 3.1.3 + fast-uri: 3.1.5 json-schema-traverse: 1.0.0 require-from-string: 2.0.2 @@ -5627,7 +5627,7 @@ snapshots: dependencies: fast-string-truncated-width: 3.0.3 - fast-uri@3.1.3: {} + fast-uri@3.1.5: {} fast-wrap-ansi@0.2.0: dependencies: @@ -5843,12 +5843,12 @@ snapshots: js-tokens@9.0.1: {} - js-yaml@3.15.0: + js-yaml@3.15.1: dependencies: argparse: 1.0.10 esprima: 4.0.1 - js-yaml@4.2.0: + js-yaml@4.3.1: dependencies: argparse: 2.0.1 @@ -5863,7 +5863,7 @@ snapshots: '@types/json-schema': 7.0.15 '@types/lodash': 4.17.21 is-glob: 4.0.3 - js-yaml: 4.2.0 + js-yaml: 4.3.1 lodash: 4.18.1 minimist: 1.2.8 prettier: 3.7.4 @@ -6019,7 +6019,7 @@ snapshots: lru.min: 1.1.4 optional: true - nanoid@3.3.12: {} + nanoid@3.3.18: {} negotiator@1.0.0: {} @@ -6028,7 +6028,7 @@ snapshots: '@next/env': 15.5.21 '@swc/helpers': 0.5.15 caniuse-lite: 1.0.30001760 - postcss: 8.5.14 + postcss: 8.5.26 react: 19.2.3 react-dom: 19.2.3(react@19.2.3) styled-jsx: 5.1.6(react@19.2.3) @@ -6187,18 +6187,18 @@ snapshots: pluralize@8.0.0: {} - postcss-load-config@6.0.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(yaml@2.9.0): + postcss-load-config@6.0.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(yaml@2.9.0): dependencies: lilconfig: 3.1.3 optionalDependencies: jiti: 2.7.0 - postcss: 8.5.14 + postcss: 8.5.26 tsx: 4.23.0 yaml: 2.9.0 - postcss@8.5.14: + postcss@8.5.26: dependencies: - nanoid: 3.3.12 + nanoid: 3.3.18 picocolors: 1.1.1 source-map-js: 1.2.1 @@ -6268,7 +6268,7 @@ snapshots: read-yaml-file@1.1.0: dependencies: graceful-fs: 4.2.11 - js-yaml: 3.15.0 + js-yaml: 3.15.1 pify: 4.0.1 strip-bom: 3.0.0 @@ -6573,7 +6573,7 @@ snapshots: tslib@2.8.1: {} - tsup@8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0): + tsup@8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0): dependencies: bundle-require: 5.1.0(esbuild@0.28.1) cac: 6.7.14 @@ -6584,7 +6584,7 @@ snapshots: fix-dts-default-cjs-exports: 1.0.1 joycon: 3.1.1 picocolors: 1.1.1 - postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(yaml@2.9.0) + postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(yaml@2.9.0) resolve-from: 5.0.0 rollup: 4.60.4 source-map: 0.7.6 @@ -6593,7 +6593,7 @@ snapshots: tinyglobby: 0.2.16 tree-kill: 1.2.2 optionalDependencies: - postcss: 8.5.14 + postcss: 8.5.26 typescript: 5.9.3 transitivePeerDependencies: - jiti @@ -6694,7 +6694,7 @@ snapshots: esbuild: 0.28.1 fdir: 6.5.0(picomatch@4.0.4) picomatch: 4.0.4 - postcss: 8.5.14 + postcss: 8.5.26 rollup: 4.60.4 tinyglobby: 0.2.16 optionalDependencies: @@ -6711,7 +6711,7 @@ snapshots: esbuild: 0.28.1 fdir: 6.5.0(picomatch@4.0.4) picomatch: 4.0.4 - postcss: 8.5.14 + postcss: 8.5.26 rollup: 4.60.4 tinyglobby: 0.2.16 optionalDependencies: diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 051d7bcdd..a8b7d9ef7 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -66,7 +66,16 @@ overrides: # #133 GHSA-qjx8-664m-686j — js-cookie attribute injection 'js-cookie@<3.0.7': '^3.0.7' # #102 GHSA-qx2v-qp2m-jg93 — postcss XSS via unescaped - 'postcss@<8.5.10': '^8.5.10' + # #167 GHSA-r28c-9q8g-f849 / CVE-2026-73646 (HIGH) — path traversal reading + # arbitrary .map files via attacker-controlled sourceMappingURL when `from` + # is unset. #176 GHSA-fxqj-rqcc-2cmp / CVE-2026-69153 is its incomplete-fix + # follow-up (patched 8.5.23). + # + # THE SELECTOR IS THE LESSON. `postcss@<8.5.10` stopped matching once the tree + # resolved 8.5.14, so the override went inert and a vulnerable version + # installed with the entry still sitting here looking like a fix. Keep the + # ceiling AHEAD of the patched floor, not at it. + 'postcss@<8.5.26': '^8.5.26' # #145 GHSA-fx2h-pf6j-xcff, #146 GHSA-v6wh-96g9-6wx3 — vite dev server (Windows) 'vite@>=7.0.0 <7.3.5': '~7.3.5' # #142 GHSA-g7r4-m6w7-qqqr — esbuild dev server. 0.28.1 is the FIRST patched @@ -75,22 +84,45 @@ overrides: # declares ^0.28. 'esbuild@>=0.27.3 <0.28.1': '^0.28.1' # #153 GHSA-h67p-54hq-rp68 / CVE-2026-53550 — js-yaml merge-key DoS, 3.x line. - # Exact pin: 3.15.0 is the only patched 3.x release. Installed with the - # one-off `--config.minimum-release-age=0` bypass (published 2026-06-26, - # matures 2026-07-04) per SKILL.md, instead of a minimumReleaseAgeExclude - # entry. - 'js-yaml@<3.15.0': '3.15.0' + # #189 GHSA-5p4m-2wfm-xmqj / CVE-2026-59870 (HIGH) — quadratic-CPU DoS in + # `!!omap` duplicate-key detection; patched in 3.15.1. + # + # The previous `<3.15.0` selector had been overtaken by its own fix: the tree + # resolved exactly 3.15.0, so nothing matched and nothing lifted it to 3.15.1. + # Reached only through `read-yaml-file`. + 'js-yaml@<3.15.1': '3.15.1' # #152 GHSA-h67p-54hq-rp68 / CVE-2026-53550 — js-yaml merge-key DoS, 4.x line. - # Exact-pinned to the MATURED 4.2.0 (4.3.0 is still inside the cooldown), and - # kept exact because a past js-yaml upgrade broke changesets — bump this - # deliberately and re-verify `changeset status`/`version` when you do. - 'js-yaml@>=4.0.0 <5': '4.2.0' - # Not a Dependabot alert — cooldown-regression guard. Re-resolving the - # lockfile let minimumReleaseAge demote ajv's fast-uri to 3.1.2, un-fixing + # #155 GHSA-52cp-r559-cp3m / CVE-2026-59869 (HIGH, patched 4.3.0) and + # #188 GHSA-5p4m-2wfm-xmqj / CVE-2026-59870 (HIGH, patched 4.3.1). + # + # THIS ENTRY WAS ENFORCING THE VULNERABILITY. Unlike the two overtaken + # selectors above, `>=4.0.0 <5` kept matching — so an exact pin written to FIX + # an advisory was holding the tree at 4.2.0 and blocking 4.3.1. An exact pin + # inside a still-matching range is the worst of the three shapes: it cannot + # self-heal and it cannot be fixed by Dependabot. + # + # The "a past js-yaml upgrade broke changesets" caution is DISCHARGED for this + # bump, checked rather than assumed: @changesets/parse declares + # `js-yaml: ^4.1.1`, which 4.3.1 satisfies; 4.2.0 and 4.3.1 have identical + # `dependencies` (argparse ^2.0.1) and `exports`, no `engines`, no `main`; + # 4.3.0/4.3.1 are security backports only (a `maxTotalMergeKeys` loader option + # and the `!!omap` fix), with no API removal on the 4.x line. The breaking + # churn — grouped constant exports, `MERGE_KEY` removal, mandatory `identify` + # — is all on 5.x, which the `<5` ceiling already excludes. Verified after the + # bump with `changeset status` and a `changeset version` dry run. + # + # Kept exact so a future 4.x regression cannot arrive silently; the ceiling + # stays `<5`. Consumers: @changesets/parse and json-schema-to-typescript. + 'js-yaml@>=4.0.0 <5': '4.3.1' + # Cooldown-regression guard AND two live advisories. Re-resolving the lockfile + # let minimumReleaseAge demote ajv's fast-uri to 3.1.2, un-fixing # GHSA-4c8g-83qw-93j6 / CVE-2026-13676 (host confusion via failed IDN - # canonicalization). Pin the patched release (published 2026-06-29, matures - # 2026-07-06); safe to relax to ^3.1.3 after that date. - 'fast-uri@<3.1.3': '3.1.3' + # canonicalization) — hence a pin rather than a floor. + # + # But 3.1.3 was itself overtaken: #158 (HIGH) needs 3.1.4 and #175 (HIGH) + # needs 3.1.5, so the exact pin was enforcing a vulnerable version — the same + # shape as the js-yaml 4.x entry above. Reached through ajv. + 'fast-uri@<3.1.5': '3.1.5' # Supply-chain hardening — see skills/stash-supply-chain-security/ # 7 days in minutes; mirrors the Dependabot cooldown so manual + automated diff --git a/scripts/__tests__/cargo-lock-freshness.test.mjs b/scripts/__tests__/cargo-lock-freshness.test.mjs new file mode 100644 index 000000000..a417b0d9c --- /dev/null +++ b/scripts/__tests__/cargo-lock-freshness.test.mjs @@ -0,0 +1,193 @@ +import { readdirSync, readFileSync } from 'node:fs' +import { join, relative, sep } from 'node:path' +import { describe, expect, it } from 'vitest' +import { REPO_ROOT } from './lib/repo-root.mjs' + +/** + * Every crate this repo owns must be recorded in every `Cargo.lock` at the + * version its own `Cargo.toml` declares. + * + * ## The drift this catches, and why nothing else does + * + * `scripts/sync-lockstep-versions.mjs` rewrites + * `packages/eql/crates/eql-bindings/Cargo.toml` on every lockstep bump — that + * is its job. `packages/protect-ffi` depends on that crate BY PATH + * (`crates/protect-ffi/Cargo.toml`), so its `Cargo.lock` records the version + * too, and nothing was updating it. After the 3.0.5 bump the lock still said + * `eql-bindings 3.0.4` and `cargo metadata --locked` exited 101. + * + * Nothing failed. Not one command in this repo passes `--locked`: + * `build:native` is a plain `cargo build --release`, so every CI job that + * touches Rust silently regenerated the lock, used the regenerated one, and + * threw it away with the runner. The committed file drifted further from the + * tree on each lockstep bump while every job stayed green. + * + * ## Why a version comparison rather than `cargo metadata --locked` + * + * `--locked` is the exact check and it needs a Rust toolchain. `AGENTS.md` is + * explicit that the default `test` and `build` scripts must never invoke cargo + * — root `pnpm test` reaches `packages/protect-ffi`, so a cargo call on that + * path is a Rust toolchain on every contributor's machine — and `pnpm run + * test:scripts` has the same reach, since everyone runs it. + * + * So this asserts the property that actually broke, with node builtins: a + * source-less `[[package]]` entry in a lock is a crate resolved from this + * tree, and its version is knowable by reading the crate's manifest. That is + * narrower than `--locked` — a lock stale because a crate gained a NEW + * dependency still passes here — but it is the whole of the lockstep failure + * mode, it runs everywhere, and it costs nothing. Pairing it with a `--locked` + * invocation on `packages/protect-ffi`'s `test:cargo` path would close the + * remainder; that script is owned elsewhere. + */ + +/** Same skip set, and the same reasons, as `lint-no-eql-registry-pins.mjs`. */ +const SKIP_DIRS = new Set([ + '.git', + 'node_modules', + 'target', + 'dist', + '.turbo', + '.next', +]) + +/** Every file named `name` under the repo, repo-relative and POSIX-spelled. */ +function findFiles(name) { + const found = [] + const walk = (abs) => { + for (const entry of readdirSync(abs, { withFileTypes: true })) { + if (entry.isDirectory()) { + if (!SKIP_DIRS.has(entry.name)) walk(join(abs, entry.name)) + } else if (entry.name === name) { + found.push(join(abs, entry.name)) + } + } + } + walk(REPO_ROOT) + return found + .map((abs) => relative(REPO_ROOT, abs).split(sep).join('/')) + .sort() +} + +/** + * `[package] name` and `version` from one `Cargo.toml`. + * + * Anchored to the `[package]` table for the reason `bumpCargoPackageVersion` + * is: a `[dependencies.foo]` long-form table also carries a column-0 + * `version = "…"` line, and reading "the first version in the file" would pick + * up whichever came first. + */ +function crateManifest(source) { + const section = source.match(/^\[package\]\n(?:(?!^\[).*\n)*/m) + if (!section) return null + const name = /^name = "([^"]*)"$/m.exec(section[0]) + const version = /^version = "([^"]*)"$/m.exec(section[0]) + return name && version ? { name: name[1], version: version[1] } : null +} + +/** + * The `[[package]]` entries of a `Cargo.lock` that resolve from THIS tree. + * + * A registry or git dependency carries a `source = "…"` key; a path dependency + * and a workspace member carry none. That absence is the whole test for + * "cargo resolved this from a directory", and it is how cargo itself + * distinguishes them. + */ +export function localLockEntries(source) { + return source + .split(/^\[\[package\]\]$/m) + .slice(1) + .map((block) => { + const name = /^name = "([^"]*)"$/m.exec(block) + const version = /^version = "([^"]*)"$/m.exec(block) + const source_ = /^source = "/m.test(block) + return name && version && !source_ + ? { name: name[1], version: version[1] } + : null + }) + .filter(Boolean) +} + +/** name -> { version, file } for every crate manifest in the tree. */ +const CRATES = new Map() +const AMBIGUOUS = [] +for (const file of findFiles('Cargo.toml')) { + const crate = crateManifest(readFileSync(join(REPO_ROOT, file), 'utf8')) + if (!crate) continue // a virtual manifest: `[workspace]` with no `[package]` + const existing = CRATES.get(crate.name) + if (existing && existing.version !== crate.version) { + AMBIGUOUS.push(`${crate.name}: ${existing.file} vs ${file}`) + } + CRATES.set(crate.name, { ...crate, file }) +} + +const LOCKS = findFiles('Cargo.lock') + +/** Every (lock, local crate) pair, with the version each side records. */ +const PAIRS = LOCKS.flatMap((lock) => + localLockEntries(readFileSync(join(REPO_ROOT, lock), 'utf8')).map( + (entry) => ({ + lock, + name: entry.name, + locked: entry.version, + onDisk: CRATES.get(entry.name)?.version ?? null, + }), + ), +) + +describe('Cargo.lock records this tree’s crates at their real versions', () => { + it('finds locks and crates to compare', () => { + // The floor. Discovery over the tree means a walk that stops matching — + // a new SKIP_DIRS entry, a rename — turns this whole file green while + // checking nothing. + expect(LOCKS.length).toBeGreaterThan(0) + expect(PAIRS.length).toBeGreaterThan(0) + }) + + it('covers eql-bindings, the crate the lockstep bump rewrites', () => { + // Named specifically because it is the one with a mechanism actively + // pushing it out of sync: `scripts/sync-lockstep-versions.mjs` writes its + // `Cargo.toml` on every release. If this crate ever drops out of the pair + // set, the check that matters most has silently stopped running. + expect(PAIRS.filter(({ name }) => name === 'eql-bindings').length).toBe( + LOCKS.length, + ) + }) + + it('resolves every locked local crate to a manifest on disk', () => { + // A source-less entry naming a crate this tree does not contain means the + // scan lost its subject — a path dependency pointing outside the repo, or + // a walk that no longer reaches the crate. Either way the comparison below + // is not being made, which must not read as a pass. + expect( + PAIRS.filter(({ onDisk }) => onDisk === null).map( + ({ lock, name }) => `${lock} :: ${name}`, + ), + ).toEqual([]) + }) + + it('has one version per crate name across the tree', () => { + // The name -> version map is keyed on the crate name alone, so two crates + // sharing a name at different versions would make the comparison depend on + // walk order. Fail rather than pick. + expect(AMBIGUOUS).toEqual([]) + }) + + it('locks each crate at the version its Cargo.toml declares', () => { + // THE DEFECT. `packages/protect-ffi/Cargo.lock` said `eql-bindings 3.0.4` + // while the crate said 3.0.5, because the lockstep sync rewrote the + // manifest and no command in this repo passes `--locked`. + const offenders = PAIRS.filter( + ({ locked, onDisk }) => locked !== onDisk, + ).map( + ({ lock, name, locked, onDisk }) => + `${lock}: ${name} locked at ${locked}, ${CRATES.get(name).file} declares ${onDisk}`, + ) + expect( + offenders, + 'A committed Cargo.lock disagrees with a crate manifest in this tree. Refresh it with ' + + '`cargo update --package ` in the workspace holding the lock. Not `--offline`: ' + + '`cargo update -p` re-resolves the WHOLE graph, so every other package has to come from ' + + 'the local registry cache, and it fails outright on a cold one.', + ).toEqual([]) + }) +}) diff --git a/scripts/__tests__/eql-matrix-triggers.test.mjs b/scripts/__tests__/eql-matrix-triggers.test.mjs new file mode 100644 index 000000000..1f0fe9f60 --- /dev/null +++ b/scripts/__tests__/eql-matrix-triggers.test.mjs @@ -0,0 +1,353 @@ +import { execFileSync } from 'node:child_process' +import { mkdtempSync, readFileSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import yaml from 'js-yaml' +import { afterAll, describe, expect, it } from 'vitest' +import { REPO_ROOT } from './lib/repo-root.mjs' +import { readWorkflow } from './lib/workflows.mjs' + +/** + * The EQL suite's full Postgres matrix must be reachable by a trigger that + * actually fires in THIS repository. + * + * WHAT HAPPENED. The workflow arrived from `cipherstash/encrypt-query-language` + * with the subtree, and its `setup` job derives the fan-out from the event: + * `merge_group` gets PG 14-17, everything else gets PG17 alone. The port also + * dropped the `push:` trigger, justified in the file header by "Under a + * required merge queue, push-to-main validation is redundant: the queue already + * validated the exact merge commit, and branch protection blocks direct + * pushes." + * + * Every clause of that premise is false here. Checked against the live repo: + * + * gh api graphql '{repository(owner:"cipherstash",name:"stack"){ + * mergeQueue(branch:"main"){id}}}' -> {"mergeQueue": null} + * gh api repos/cipherstash/stack/branches/main/protection + * -> 404 "Branch not protected" + * the active ruleset (id 4478501) carries only `deletion`, `pull_request` + * (1 approval), `non_fast_forward` and `required_signatures` — there is NO + * `required_status_checks` rule, so `ci-required` is required by nothing. + * + * `merge_group` is therefore an event this repository never emits. `test-eql.yml` + * is the only workflow in the tree that declares it, and it was the sole gate on + * the full matrix — so PG 14, 15 and 16 were tested NEVER, and with `push:` + * gone nothing EQL-related ran post-merge at all. Both failures are invisible: + * an event that is never delivered produces no runs to notice the absence of. + * + * WHY THE PROPERTY IS SPELLED THIS WAY. A test in the tree cannot query repo + * settings, and one that could would be asserting about a mutable dashboard + * rather than about this file. So the invariant is encoded structurally: the + * full matrix must be reachable from `push`, `schedule` or `pull_request` — + * events GitHub delivers on its own. `merge_group` and `workflow_dispatch` are + * deliberately excluded: the first requires a merge queue that does not exist, + * the second requires a human to press a button, and "someone could run it by + * hand" is not coverage. If a merge queue is turned on later, `merge_group` may + * be ADDED to the full-matrix path — it may not become the only one again + * without deleting this test on purpose. + * + * The fan-out is not re-derived here, it is EXECUTED: the `setup` job's script + * is run once per candidate event and its real `$GITHUB_OUTPUT` is read back. + * A guard that reimplemented the if/else would agree with a rewritten script + * exactly as often as it disagreed. + */ + +const WORKFLOW = '.github/workflows/test-eql.yml' +const COMPOSE = 'packages/eql/tests/docker-compose.yml' + +/** + * The events GitHub delivers without a merge queue and without a human. The + * whole point of the file — see the header. + */ +const SELF_FIRING_EVENTS = ['push', 'schedule', 'pull_request'] + +/** Every event the check evaluates the matrix under. */ +const CANDIDATE_EVENTS = [ + ...SELF_FIRING_EVENTS, + 'merge_group', + 'workflow_dispatch', +] + +const wf = readWorkflow(WORKFLOW) + +/** `on:` parses as the boolean `true` under YAML 1.1 — the "Norway problem". */ +const TRIGGERS = (() => { + const on = wf?.on ?? wf?.[true] + return on && typeof on === 'object' ? on : {} +})() + +const DECLARED = CANDIDATE_EVENTS.filter((event) => event in TRIGGERS) + +/** + * The Postgres versions this suite ships a container for, read from the compose + * file the `postgres:up` task drives rather than listed here. + * + * Derived because the two lists are one claim: a `postgres-18` service that no + * matrix ever selects is a version nobody tests, which is the same defect as + * the one above wearing different clothes. + */ +function supportedPostgresVersions() { + const compose = yaml.load(readFileSync(join(REPO_ROOT, COMPOSE), 'utf8')) + return Object.keys(compose?.services ?? {}) + .map((name) => /^postgres-(\d+)$/.exec(name)) + .filter(Boolean) + .map((match) => Number(match[1])) + .sort((a, b) => a - b) +} + +const SUPPORTED_PG = supportedPostgresVersions() + +// --------------------------------------------------------------------------- +// Following the workflow's own data flow to the script that computes the matrix +// --------------------------------------------------------------------------- + +/** `${{ needs..outputs. }}` -> `{ job, output }`, else null. */ +function needsOutputRef(expression) { + const match = /needs\.([A-Za-z0-9_-]+)\.outputs\.([A-Za-z0-9_-]+)/.exec( + String(expression ?? ''), + ) + return match ? { job: match[1], output: match[2] } : null +} + +/** + * The step that produces `jobs..outputs.`, found by resolving the + * output expression to a step `id`. + * + * Discovery rather than a named constant: the coupling being checked is + * matrix -> job output -> step, and following it means a renamed job or step + * fails this file loudly instead of leaving it checking a script nothing runs. + */ +function stepProducing({ job, output }) { + const definition = wf?.jobs?.[job] + const ref = /steps\.([A-Za-z0-9_-]+)\.outputs\./.exec( + String(definition?.outputs?.[output] ?? ''), + ) + if (!ref) return null + const step = (definition?.steps ?? []).find((entry) => entry?.id === ref[1]) + return step ? { job, stepId: ref[1], step } : null +} + +/** The job output the matrix's `postgres-version` axis is computed from. */ +const MATRIX_SOURCE = (() => { + for (const job of Object.values(wf?.jobs ?? {})) { + const axis = job?.strategy?.matrix?.['postgres-version'] + const ref = needsOutputRef(axis) + if (ref) return ref + } + return null +})() + +/** The relevance flag every gated job's `if:` reads. */ +const RELEVANCE_SOURCE = (() => { + for (const job of Object.values(wf?.jobs ?? {})) { + const ref = needsOutputRef(job?.if) + if (ref) return ref + } + return null +})() + +const MATRIX_STEP = MATRIX_SOURCE ? stepProducing(MATRIX_SOURCE) : null +const RELEVANCE_STEP = RELEVANCE_SOURCE ? stepProducing(RELEVANCE_SOURCE) : null + +/** + * The step `env:` key wired to `${{ github.event_name }}`. + * + * The script has to read the event from the environment rather than from an + * inlined `${{ }}`, precisely so it can be executed here against each event in + * turn. That is not a concession to the test: an expression interpolated into a + * shell body is unrunnable, unquotable and — for anything less fixed than an + * event name — an injection site. + */ +function eventEnvKey(step) { + return ( + Object.entries(step?.env ?? {}).find(([, value]) => + /^\$\{\{\s*github\.event_name\s*\}\}$/.test(String(value)), + )?.[0] ?? null + ) +} + +const SCRATCH = mkdtempSync(join(tmpdir(), 'eql-matrix-triggers-')) +afterAll(() => rmSync(SCRATCH, { recursive: true, force: true })) + +let runCounter = 0 + +/** + * Run a step's `run:` body under a synthetic event and return the key/value + * pairs it wrote to `$GITHUB_OUTPUT`. + * + * Every OTHER `env:` entry is set to the empty string, which is what GitHub + * actually substitutes for an expression that resolves to nothing — the + * relevance step reads `steps.f.outputs.relevant`, and step `f` is skipped on + * every event but `pull_request`. + */ +function runStep({ step }, eventName) { + const envKey = eventEnvKey(step) + runCounter += 1 + const outputFile = join(SCRATCH, `outputs-${runCounter}.txt`) + writeEmpty(outputFile) + + const env = { PATH: process.env.PATH, GITHUB_OUTPUT: outputFile } + for (const key of Object.keys(step?.env ?? {})) env[key] = '' + env[envKey] = eventName + + execFileSync('bash', ['-c', String(step.run)], { + cwd: SCRATCH, + env, + encoding: 'utf8', + }) + + return Object.fromEntries( + readFileSync(outputFile, 'utf8') + .split('\n') + .filter(Boolean) + .map((line) => { + const at = line.indexOf('=') + return [line.slice(0, at), line.slice(at + 1)] + }), + ) +} + +function writeEmpty(path) { + execFileSync('bash', ['-c', ': > "$1"', 'bash', path]) +} + +/** The Postgres versions the matrix fans out to under one event. */ +function pgVersionsFor(eventName) { + const outputs = runStep(MATRIX_STEP, eventName) + const raw = outputs[MATRIX_SOURCE.output.replace(/-/g, '_')] ?? outputs.pg + return JSON.parse(raw) + .map(Number) + .sort((a, b) => a - b) +} + +const isFullMatrix = (versions) => + SUPPORTED_PG.every((version) => versions.includes(version)) + +describe('the EQL matrix is reachable by a trigger that fires', () => { + it('follows the workflow to the script that computes the fan-out', () => { + // Every assertion below runs that script. If the trail from the matrix axis + // to it breaks, this file would otherwise report success having executed + // nothing — the failure mode the whole directory guards against. + expect( + MATRIX_SOURCE, + `No job in ${WORKFLOW} derives \`strategy.matrix.postgres-version\` from a \`needs..outputs.\` expression, so there is no fan-out to evaluate.`, + ).toBeTruthy() + expect( + MATRIX_STEP, + `\`jobs.${MATRIX_SOURCE?.job}.outputs.${MATRIX_SOURCE?.output}\` does not resolve to a step \`id:\` in that job.`, + ).toBeTruthy() + expect( + eventEnvKey(MATRIX_STEP?.step), + `The "${MATRIX_SOURCE?.job}" job's \`${MATRIX_STEP?.stepId}\` step must read the event from its \`env:\` (a key set to \`\${{ github.event_name }}\`) rather than interpolating the expression into the shell body. An inlined expression cannot be executed here, so this guard would silently stop evaluating the real fan-out.`, + ).toBeTruthy() + + expect( + SUPPORTED_PG.length, + `${COMPOSE} declares fewer than two \`postgres-\` services, so "the full matrix" is not a meaningful claim. Either the compose file was restructured or the service naming changed.`, + ).toBeGreaterThanOrEqual(2) + }) + + it('runs the full matrix under at least one event', () => { + // Separated from the check below so the two failures read differently: this + // one means the workflow no longer HAS a full-matrix path, which is a much + // larger finding than it having one behind the wrong trigger. + const full = CANDIDATE_EVENTS.filter((event) => + isFullMatrix(pgVersionsFor(event)), + ) + expect( + full, + `No event makes ${WORKFLOW} fan out across every Postgres version in ${COMPOSE} (${SUPPORTED_PG.join(', ')}). Per event:\n${CANDIDATE_EVENTS.map((event) => ` ${event}: PG ${pgVersionsFor(event).join(', ')}`).join('\n')}`, + ).not.toEqual([]) + }) + + it('reaches the full matrix from a trigger this repo actually emits', () => { + const reaching = SELF_FIRING_EVENTS.filter( + (event) => DECLARED.includes(event) && isFullMatrix(pgVersionsFor(event)), + ) + expect( + reaching, + `${WORKFLOW} gates its full Postgres matrix behind events this repository never delivers on its own.\nDeclared triggers: ${DECLARED.join(', ') || '(none)'}\nPer event:\n${CANDIDATE_EVENTS.map((event) => ` ${event}: ${DECLARED.includes(event) ? '' : '(not declared) '}PG ${pgVersionsFor(event).join(', ')}`).join('\n')}\nThere is no merge queue on \`main\` and no \`required_status_checks\` rule (see this file's header for the API responses), so \`merge_group\` never fires and \`workflow_dispatch\` needs a human. Give the full matrix a \`push\`, \`schedule\` or \`pull_request\` path.`, + ).not.toEqual([]) + }) + + it('keeps a post-merge run of some shape', () => { + // Weaker than the check above and not implied by it: a nightly `schedule` + // satisfies the full-matrix property while leaving every merge to `main` + // unvalidated until 02:00. Both halves were lost in the same edit. + expect( + DECLARED.filter((event) => event === 'push' || event === 'schedule'), + `${WORKFLOW} declares neither \`push\` nor \`schedule\`, so nothing EQL-related runs after a pull request merges. With no branch protection and no merge queue on \`main\`, the pre-merge run is the ONLY run — and it validated the head commit, not the merge result.`, + ).not.toEqual([]) + }) +}) + +describe('the relevance flag opens on every non-PR event', () => { + it('follows the workflow to the step that computes it', () => { + expect( + RELEVANCE_SOURCE, + `No job \`if:\` in ${WORKFLOW} reads a \`needs..outputs.\` relevance flag, so this suite has nothing to evaluate.`, + ).toBeTruthy() + expect(RELEVANCE_STEP).toBeTruthy() + expect( + eventEnvKey(RELEVANCE_STEP?.step), + `The "${RELEVANCE_SOURCE?.job}" job's \`${RELEVANCE_STEP?.stepId}\` step must read the event from its \`env:\` rather than inlining \`\${{ github.event_name }}\`, for the reason given on the matrix step.`, + ).toBeTruthy() + }) + + for (const event of CANDIDATE_EVENTS.filter((e) => e !== 'pull_request')) { + it(`defaults to relevant on ${event}`, () => { + // The path filter only runs on `pull_request` — it needs a base ref — so + // on every other event the flag is a hardcoded default. Get that default + // wrong and every gated job skips on the new trigger while the run still + // reports success, which is the same silent-skip class as the trigger bug + // this file exists for. + const outputs = runStep(RELEVANCE_STEP, event) + expect( + outputs[RELEVANCE_SOURCE.output], + `The relevance step wrote ${JSON.stringify(outputs)} on a ${event} event. Every heavy job is gated on this being 'true', and the filter that would compute it does not run outside \`pull_request\`.`, + ).toBe('true') + }) + } +}) + +/** + * The structural half, and the one that outlives the specific trigger added + * today. + * + * Every gated job here was written as an ALLOWLIST of events — + * `merge_group || workflow_dispatch || (pull_request && relevant)` — which is + * the exact defect `workflow-dispatch-job-conditions.test.mjs` was written for + * one workflow over: a condition that enumerates the events known at writing + * time fails SHUT on the one nobody enumerated. Add a trigger and every job + * skips, the run reports success, and nothing says the suite did not execute. + * + * The corrected form is the same inversion that file prescribes: name the case + * that must NOT run — a pull request whose diff is irrelevant, or one from a + * fork that has no secrets — and let every other event through. So the rule is + * mechanical: no job condition in this workflow may test `github.event_name` + * for EQUALITY. + */ +describe('no job condition enumerates the events it will run on', () => { + const CONDITIONS = Object.entries(wf?.jobs ?? {}) + .filter(([, job]) => job?.if !== undefined) + .map(([jobName, job]) => ({ jobName, condition: String(job.if) })) + + it('finds the job conditions it means to check', () => { + expect( + CONDITIONS.map((entry) => entry.jobName), + `No job in ${WORKFLOW} carries an \`if:\`, so this check iterates nothing. Either the gating moved or the file was restructured.`, + ).not.toEqual([]) + }) + + for (const { jobName, condition } of CONDITIONS) { + it(`${jobName} gates on what must not run, not on what may`, () => { + const allowlisted = [ + ...condition.matchAll(/github\.event_name\s*==\s*'([^']*)'/g), + ].map((match) => match[1]) + expect( + allowlisted, + `The \`if:\` on "${jobName}" enumerates the events it runs on:\n if: ${condition}\nA trigger added later matches none of these clauses, so every job skips, the run reports success, and nothing indicates the suite did not execute — which is the failure this workflow already shipped once. Invert it: \`github.event_name != 'pull_request' || \`.`, + ).toEqual([]) + }) + } +}) diff --git a/scripts/__tests__/eql-suite-ci.test.mjs b/scripts/__tests__/eql-suite-ci.test.mjs index e030ecb78..ca1bd1947 100644 --- a/scripts/__tests__/eql-suite-ci.test.mjs +++ b/scripts/__tests__/eql-suite-ci.test.mjs @@ -1,6 +1,6 @@ import { execFileSync } from 'node:child_process' -import { existsSync, readFileSync } from 'node:fs' -import { join } from 'node:path' +import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs' +import { join, relative, sep } from 'node:path' import yaml from 'js-yaml' import { describe, expect, it } from 'vitest' import { REPO_ROOT } from './lib/repo-root.mjs' @@ -35,6 +35,13 @@ import { readWorkflow, WORKFLOW_DIR, workflowFiles } from './lib/workflows.mjs' /** The EQL suite's own workflow, at the only path GitHub reads. */ const EQL_WORKFLOW = `${WORKFLOW_DIR}/test-eql.yml` +/** + * The nightly/push-only bench workflow, named because it is the SOLE caller of + * a cargo check (`test:bench`) and therefore the subject of the mutation test + * at the bottom of this file. + */ +const BENCH_WORKFLOW = `${WORKFLOW_DIR}/bench-eql.yml` + /** A `.github` deposited inside the package by the subtree import. */ const DEAD_GITHUB_DIR = 'packages/eql/.github' @@ -142,16 +149,35 @@ describe('the relevance filter still selects the imported tree', () => { ).not.toEqual([]) }) + /** + * The composite actions this workflow reaches through `uses: ./…`. + * + * They are the second legitimate class of non-subtree path, alongside the + * workflow's own file: `require-cs-secrets` lives at the repository root, and + * a change to it changes what every credentialed EQL job does — so it belongs + * in the relevance filter. Derived from the `uses:` edges rather than + * allowlisted by name, so adding an action to the workflow and to the filter + * needs no edit here, while an unrelated root path still fails. + */ + const localActionPrefixes = Object.values(wf?.jobs ?? {}) + .flatMap((job) => job?.steps ?? []) + .map((step) => step?.uses ?? '') + .filter((uses) => uses.startsWith('./')) + .map((uses) => `${uses.slice('./'.length)}/`) + it('prefixes every source path with the subtree root', () => { - // The workflow's own path is the one legitimate exception: it lives at the - // repository root, not inside the subtree. + // Two legitimate exceptions, both outside the subtree by nature: the + // workflow's own path, and a composite action it `uses:`. const offenders = filterPaths.filter( - (path) => path !== EQL_WORKFLOW && !path.startsWith(EQL_PREFIX), + (path) => + path !== EQL_WORKFLOW && + !path.startsWith(EQL_PREFIX) && + !localActionPrefixes.some((prefix) => path.startsWith(prefix)), ) expect( offenders, - `These \`paths:\` entries in ${EQL_WORKFLOW} are not under \`${EQL_PREFIX}\`. dorny/paths-filter matches repo-root-relative paths, so after the subtree import an unprefixed glob matches the WRONG tree — \`src/**\` selects \`packages/stack/src/**\` and never \`packages/eql/src/**\`. The heavy jobs then skip on real EQL changes, report \`skipped\`, and \`ci-required\` treats skipped as pass.\n${offenders.map((p) => ` ${p}`).join('\n')}`, + `These \`paths:\` entries in ${EQL_WORKFLOW} are not under \`${EQL_PREFIX}\`, are not the workflow itself, and are not a composite action it \`uses:\`. dorny/paths-filter matches repo-root-relative paths, so after the subtree import an unprefixed glob matches the WRONG tree — \`src/**\` selects \`packages/stack/src/**\` and never \`packages/eql/src/**\`. The heavy jobs then skip on real EQL changes, report \`skipped\`, and \`ci-required\` treats skipped as pass.\n${offenders.map((p) => ` ${p}`).join('\n')}`, ).toEqual([]) }) @@ -187,20 +213,111 @@ describe('the relevance filter still selects the imported tree', () => { * CI itself. * * So this asserts the property one level up: a mise task that compiles or runs - * Rust must be reached by some workflow GitHub actually executes. Fifteen tasks - * qualify, and they arrived from a repository where a different set of + * Rust must be reached by some workflow GitHub actually executes. Twenty-six + * tasks qualify, and they arrived from a repository where a different set of * workflows ran them — which is exactly the state in which one goes quiet * without anyone noticing. + * + * ## Why the scan is as long as it is + * + * The first version of it parsed one shape (`[tasks."name"]`) out of three + * hard-coded files and closed reachability over `depends` alone. That missed + * three whole classes of task, and the floors it guarded itself with — "at + * least 30 tasks", "at least 18 cargo tasks" — were satisfiable by + * `packages/eql/mise.toml` on its own, so the two configs contributing NOTHING + * were invisible. Mutation-tested: with that scan in place, deleting + * `bench-eql.yml` (the sole caller of `test:bench`) left all 14 assertions + * green. Everything below exists because of one of those three classes. */ -const MISE_CONFIGS = [ - 'packages/eql/mise.toml', - 'packages/eql/tasks/fixtures.toml', - 'packages/eql/tasks/postgres.toml', -] +/** The imported package, and mise's entry point inside it. */ +const EQL_PACKAGE = 'packages/eql' +const MISE_TOML = `${EQL_PACKAGE}/mise.toml` + +const readRepo = (relPath) => readFileSync(join(REPO_ROOT, relPath), 'utf8') + +/** The `["a", 'b']` inside a TOML array, without a TOML parser. */ +const parseStringArray = (inner) => + [...inner.matchAll(/"([^"]+)"|'([^']+)'/g)].map((m) => m[1] ?? m[2]) + +/** + * `[task_config].includes`, read rather than hard-coded. + * + * The list used to be a `MISE_CONFIGS` const here, which is a copy of a + * declaration that lives in mise.toml — and the failure mode of a stale copy is + * the one this file is about: a fourth config lands, this scan never opens it, + * and every task in it becomes unguarded silently. Reading the real list means + * a new entry is covered the day it is added; `TASK_SOURCES` below then insists + * each entry actually yielded a task, so an entry that resolves to nothing + * fails rather than contributing nothing. + */ +function parseIncludes(miseText) { + const section = /^\[task_config\][^\n]*\n([\s\S]*?)(?=^\[|$)/m.exec(miseText) + const array = /^includes\s*=\s*\[([^\]]*)\]/m.exec(section?.[1] ?? '') + return array ? parseStringArray(array[1]) : [] +} + +/** + * mise's task blocks, without a TOML parser. + * + * Adding one is an audit decision in this repo, and the shape needed here is + * small: a table header, an optional `depends = [...]`, and the body text. + * + * The two dialects are NOT interchangeable, and merging them would be wrong in + * both directions. In `mise.toml` a task is `[tasks."name"]` and a bare + * `[settings]` / `[tools]` / `[env]` table is configuration. In a file named by + * `includes` the whole document is tasks, so EVERY top-level table is a task + * name and `[tasks."name"]` is not a task at all — mise rejects the file with + * "unknown field `name`, expected one of `description`, `alias`, …". That is + * why `tasks/postgres.toml` writes `["postgres:up"]` and `tasks/fixtures.toml` + * writes `["fixture:generate:all"]`, and why the old single regex parsed 0 of + * their 6 tasks. + */ +function parseTomlTasks(text, { bareTables }) { + const header = bareTables + ? /^\[(?:"([^"]+)"|([\w:.-]+))\]/ + : /^\[tasks\.(?:"([^"]+)"|([\w:.-]+))\]/ + return text + .split(/^(?=\[)/m) // split on top-level table headers; keep header + body + .map((block) => ({ match: header.exec(block), block })) + .filter(({ match }) => match) + .map(({ match, block }) => ({ name: match[1] ?? match[2], block })) +} /** - * The scripts a task block delegates to, inlined. + * A task's `depends`, from either dialect. + * + * TOML tasks spell it `depends = ["build"]`. FILE tasks spell it as a header + * comment, `#MISE depends=["build"]` — `tasks/docs/validate/source.sh` and + * three siblings carry one, and it is a real edge: without it those tasks are + * unreachable-from and `build` loses a caller. + */ +function parseDepends(text) { + const m = /^[ \t]*(?:#MISE[ \t]+)?depends\s*=\s*\[([^\]]*)\]/m.exec(text) + return m ? parseStringArray(m[1]) : [] +} + +/** + * Comment lines, in both TOML and shell. Prose is not a step — see `invokes` + * and `scriptBodies`, which both read a body only after this has run. + * + * Memoised on the exact input string. The mutation test below re-runs the whole + * reachability walk once per workflow, so this is called tens of thousands of + * times over the same ~100 bodies; without the cache that test spends most of a + * second re-stripping text and starts flaking against vitest's 5s timeout. + */ +const strippedBodies = new Map() +function stripCommentLines(text) { + let stripped = strippedBodies.get(text) + if (stripped === undefined) { + stripped = text.replace(/^[ \t]*#.*$/gm, '') + strippedBodies.set(text, stripped) + } + return stripped +} + +/** + * The scripts a task delegates to, inlined. * * Most of EQL's heavier tasks are one line — `run = "bash tasks/test/foo.sh"` — * and every cargo invocation lives in the script. Reading only the block would @@ -209,96 +326,255 @@ const MISE_CONFIGS = [ * class of task most worth checking. One hop is enough: no script here invokes * another via a second `tasks/` path. * + * Comment lines are stripped first, and that is not cosmetic. `tasks/build.sh` + * lists eight sibling scripts in a `#MISE sources=[…]` header (cache- + * invalidation inputs, not delegations) and `prepare-bindings-assets.sh` + * mentions `tasks/build.sh` in prose. Inlining those makes a task look like it + * shells to cargo when it does not — `release:prepare-bindings-assets` was + * reported as an unreached cargo check on the strength of one comment. + * * A path that does not resolve contributes nothing rather than throwing — a * task naming a script that does not exist is a different defect, and mise * fails loudly on it. */ -function scriptBodies(block) { - const paths = [...block.matchAll(/\btasks\/[\w./-]+\.sh\b/g)].map((m) => m[0]) - return paths - .map((rel) => { - const abs = join(REPO_ROOT, 'packages/eql', rel) - return existsSync(abs) ? readFileSync(abs, 'utf8') : '' - }) +function scriptBodies(text) { + return [...stripCommentLines(text).matchAll(/\btasks\/[\w./-]+\.sh\b/g)] + .map((m) => join(REPO_ROOT, EQL_PACKAGE, m[0])) + .map((abs) => (existsSync(abs) ? readFileSync(abs, 'utf8') : '')) .join('\n') } /** - * mise's task blocks, without a TOML parser. + * Every executable regular file under a directory, recursively and in a stable + * order. * - * Adding one is an audit decision in this repo, and the shape needed here is - * small: a `[tasks.""]` header, an optional `depends = [...]`, and the - * body text. `taskGraph` is guarded below on both the task count and a named - * sample, so a format change empties nothing silently — it fails. + * The executable bit IS the inclusion rule — mise makes a file under an + * `includes` directory a task if and only if it can be executed, and this + * repository leans on that distinction deliberately. `tasks/build/ordering.sh` + * and `tasks/test/stub-fixtures.sh` are `source`d by other scripts rather than + * run, `tasks/test/{doc-anchors,sqlx-archive,sqlx-partition}.sh` are invoked as + * `bash tasks/...` from a TOML task, and `symbol_order_allowlist.txt`, + * `*.sql` and the two included `*.toml` are data. All nine are mode 644 and all + * nine are correctly excluded by this one rule — no extension allowlist, which + * would have to guess about `tasks/githooks/pre-commit` (no extension, a task) + * and `tasks/docs/generate/xml-to-json.py` (a `.py`, also a task). + * + * The mode is what git records (100755 vs 100644), so a CI checkout reproduces + * this exactly; it is not a property of one developer's umask. + */ +function executableFilesUnder(absDir) { + return readdirSync(absDir, { withFileTypes: true }) + .sort((a, b) => (a.name < b.name ? -1 : 1)) + .flatMap((entry) => { + const abs = join(absDir, entry.name) + if (entry.isDirectory()) return executableFilesUnder(abs) + if (!entry.isFile()) return [] + // The POSIX mode is a bitfield; `& 0o111` is "executable by anyone". + return (statSync(abs).mode & 0o111) !== 0 ? [abs] : [] + }) +} + +/** + * The task name mise derives from a file's path under an `includes` directory: + * directory separators become `:`, and the last extension is dropped — + * `tasks/test/bench.sh` is `test:bench`, `tasks/githooks/pre-commit` is + * `githooks:pre-commit`, `tasks/release/prepare-bindings-assets.test.sh` is + * `release:prepare-bindings-assets.test` (only the LAST extension goes). + * + * The exception is a collision. `tasks/test/known-failures.sh` would be + * `test:known-failures`, which `mise.toml` already defines; mise keeps the + * extension and calls the file task `test:known-failures.sh` instead. Modelling + * that matters here — collapse the two and the file task overwrites the TOML + * one, taking its `depends` and its body with it, and `test:known-failures` + * (which test-eql.yml really does run) stops resolving to the task CI runs. + * + * All three rules were checked against `mise tasks ls --hidden --json` on this + * tree: 73 tasks, and this derivation reproduces all 73 names exactly. + */ +function fileTaskName(relPath, isTaken) { + const segments = relPath.split(sep).join('/').split('/') + const base = segments.pop() + const stem = [...segments, base.replace(/\.[^.]+$/, '')].join(':') + return isTaken(stem) ? [...segments, base].join(':') : stem +} + +/** + * The whole task graph, plus which config each task came from. + * + * `TASK_SOURCES` is not bookkeeping — it is the guard that would have caught + * the original defect. Two of the three configs contributed zero tasks and no + * assertion noticed, because the only floors were on the TOTAL. */ function taskGraph() { const tasks = new Map() - for (const rel of MISE_CONFIGS) { - const text = readFileSync(join(REPO_ROOT, rel), 'utf8') - // Split on top-level table headers; keep the header with its body. - const blocks = text.split(/^(?=\[)/m) - for (const block of blocks) { - const header = /^\[tasks\.(?:"([^"]+)"|([\w:.-]+))\]/.exec(block) - if (!header) continue - const name = header[1] ?? header[2] - const depends = /^depends\s*=\s*\[([^\]]*)\]/m.exec(block) - tasks.set(name, { - file: rel, - body: block + scriptBodies(block), - depends: depends - ? [...depends[1].matchAll(/"([^"]+)"|'([^']+)'/g)].map( - (m) => m[1] ?? m[2], - ) - : [], - }) + const bySource = new Map() + + const add = (source, name, body, depends) => { + tasks.set(name, { source, body: body + scriptBodies(body), depends }) + bySource.get(source).push(name) + } + + // mise.toml first, and the order is load-bearing: the file-task collision + // rule above asks whether a name is already taken. + const miseText = readRepo(MISE_TOML) + bySource.set(MISE_TOML, []) + for (const { name, block } of parseTomlTasks(miseText, { + bareTables: false, + })) { + add(MISE_TOML, name, block, parseDepends(block)) + } + + for (const include of parseIncludes(miseText)) { + const rel = `${EQL_PACKAGE}/${include}` + const abs = join(REPO_ROOT, rel) + // A missing include is not silently skipped: the empty source it leaves + // behind fails the per-config assertion below, which is the point. + const isDir = existsSync(abs) && statSync(abs).isDirectory() + const source = isDir ? `${rel}/**` : rel + bySource.set(source, bySource.get(source) ?? []) + if (!existsSync(abs)) continue + + if (isDir) { + for (const fileAbs of executableFilesUnder(abs)) { + const body = readFileSync(fileAbs, 'utf8') + const name = fileTaskName(relative(abs, fileAbs), (n) => tasks.has(n)) + add(source, name, body, parseDepends(body)) + } + } else { + const text = readRepo(rel) + for (const { name, block } of parseTomlTasks(text, { + bareTables: true, + })) { + add(source, name, block, parseDepends(block)) + } } } - return tasks + + return { tasks, bySource } } -const TASKS = taskGraph() +const { tasks: TASKS, bySource: TASK_SOURCES } = taskGraph() +const INCLUDES = parseIncludes(readRepo(MISE_TOML)) -/** Tasks whose body shells out to cargo. */ +/** + * Tasks whose body shells out to cargo. + * + * Deliberately matched against the RAW body, comments included. Over-matching + * costs one exemption with a reason; under-matching drops a real cargo check + * out of the set this file exists to police, and nothing downstream would say + * so. + */ const CARGO_TASKS = [...TASKS] .filter(([, task]) => /(^|[^\w-])cargo(\s|$)/m.test(task.body)) .map(([name]) => name) .sort() /** - * Whether a workflow's executable part invokes a task BY NAME. + * The positions a real command can start at: the beginning of a line, after a + * shell separator, or after a YAML `run:` key. See `invokes`. + */ +const COMMAND_START = String.raw`(?:^|&&|\|\||[;|(){}]|(? other !== name && invokes(task.body, other), + ), + ]) +} + +/** + * Task names the given workflows run, closed over both edge kinds. + * + * The workflow list is a PARAMETER, not a read of the directory, so the + * mutation test at the bottom can delete a workflow without deleting a file. + */ +function reachableFrom(tasks, workflows) { const seen = new Set() - const queue = [...TASKS.keys()].filter((name) => - rootWorkflows.some(({ body }) => invokes(body, name)), + const queue = [...tasks.keys()].filter((name) => + workflows.some(({ body }) => invokes(body, name)), ) while (queue.length > 0) { const name = queue.pop() if (seen.has(name)) continue seen.add(name) - queue.push(...(TASKS.get(name)?.depends ?? [])) + queue.push(...(tasks.get(name)?.calls ?? [])) } return seen } /** - * Cargo tasks no workflow runs, each with the reason. Every entry is either a - * developer convenience or the WRITE half of a regenerate-and-diff pair whose - * READ half is in CI — never "we decided not to check this". + * Cargo tasks no workflow runs, each with the reason. Every entry is one of: + * + * (a) a developer convenience — a watcher, an unsharded local run; + * (b) the WRITE half of a regenerate-and-diff pair whose READ half is in CI; + * (c) a second mise NAME for work CI already does under another name; + * (d) blocked on a workflow that has not been ported yet, tracked in + * UNPORTED_DEPOSIT at the bottom of this file. + * + * Never "we decided not to check this". An entry that stops describing an + * unreached cargo task fails the staleness check below, in both directions — so + * (d) in particular expires by itself the day its workflow is ported. */ const CI_EXEMPT_CARGO_TASKS = new Map([ [ @@ -318,33 +594,145 @@ const CI_EXEMPT_CARGO_TASKS = new Map([ 'test:codegen', "The generator's own unit tests, which `test:crates` already runs as part of the workspace. CI runs the stronger check: `codegen:parity` regenerates and diffs against the golden output.", ], + [ + 'codegen-parity', + 'A second mise NAME for `tasks/codegen-parity.sh`: the script is executable and sits under an `includes` directory, so mise exposes it as a file task in addition to the `[tasks."codegen:parity"]` block that runs `bash tasks/codegen-parity.sh`. CI runs that block, in test-eql.yml `codegen`. Same script, same check, one name.', + ], + [ + 'schemas-parity', + 'The same duplicate-name case as `codegen-parity`, for `tasks/schemas-parity.sh`. CI runs it as `test:schemas:parity`, in test-eql.yml `codegen`.', + ], + [ + 'test:lint', + '`cargo fmt --check` scoped to tests/sqlx. `test:crates` runs `cargo fmt --check` at the EQL workspace ROOT, and tests/sqlx is a workspace member, so the CI run covers exactly these files and four crates more — verified against `cargo fmt --check -v`, which lists packages/eql/tests/sqlx/** among its targets. test-eql.yml says the same thing at the `rust-crates` job, which is where the standalone lint step used to be.', + ], + [ + 'docs:generate:json', + 'Generates docs/api/json/eql-manifest.json for the release docs bundle. Its only caller is `packages/eql/.github/workflows/_build-docs.yml` — one of the four unported RELEASE workflows in UNPORTED_DEPOSIT — so this is category (d): it becomes reachable the day that file is ported, and this entry then goes stale and must be deleted. It is also not portable as-is, since it falls back to `mise run docs:generate`, which needs a doxygen binary no job installs. Its cargo step (`cargo run -p eql-codegen dump-catalog`) is separately exercised in CI by `test:matrix:catalog-coverage`.', + ], ]) -describe('every cargo check EQL owns is reached by a root workflow', () => { - const reachable = reachableFromCi() - - it('parses the mise task graph', () => { - // The guard on the scan. A `[tasks."x"]` spelling change, or a config file - // moving, would empty `TASKS` — and every check below would then pass - // having examined nothing. - expect(TASKS.size).toBeGreaterThanOrEqual(30) - expect([...TASKS.keys()]).toContain('test:sqlx:archive') +/** Cargo tasks a given reachability set leaves unaccounted for. */ +const orphanCargoTasks = (reachable) => + CARGO_TASKS.filter( + (name) => !reachable.has(name) && !CI_EXEMPT_CARGO_TASKS.has(name), + ) + +describe('the scan sees every task mise sees', () => { + it('reads the include list out of mise.toml', () => { + // If this parse fails, every included config below disappears at once and + // the per-source check has nothing left to find empty. + expect( + INCLUDES, + `Could not read \`[task_config].includes\` from ${MISE_TOML}. Everything mise loads beyond mise.toml itself is named there, so an unparsed list means this whole scan reads one file and reports success.`, + ).toContain('tasks') + }) + + it('draws at least one task from every config, and from the file walk', () => { + // THE property whose absence made the original defect invisible. + // `tasks/postgres.toml` and `tasks/fixtures.toml` contributed zero tasks + // for the life of the old scan — it looked only for `[tasks."x"]`, and + // those files use the bare-table form — while `TASKS.size >= 30` passed on + // mise.toml's 32 blocks alone. A floor on the total cannot see a config + // that goes quiet; a floor per config is the only shape that can. + const empty = [...TASK_SOURCES] + .filter(([, names]) => names.length === 0) + .map(([source]) => source) + + expect( + empty, + `These task configs contributed no tasks at all. Either the file moved, or its table syntax is a shape the parser does not know. A config contributing zero is indistinguishable from a config full of tasks that all pass:\n${empty + .map((s) => ` ${s}`) + .join('\n')}`, + ).toEqual([]) + + // One source per `includes` entry, plus mise.toml itself. Catches an entry + // that resolved to nothing at all rather than to an empty file. + expect(TASK_SOURCES.size).toBe(INCLUDES.length + 1) + }) + + it('names a task from each source, so a source cannot be full of nonsense', () => { + // Non-emptiness would be satisfied by a parser that read table headers as + // gibberish. These four pin one real name per source. + const from = (source) => TASK_SOURCES.get(source) ?? [] + expect(from(MISE_TOML)).toContain('test:sqlx:archive') + expect(from(`${EQL_PACKAGE}/tasks/postgres.toml`)).toContain('postgres:up') + expect(from(`${EQL_PACKAGE}/tasks/fixtures.toml`)).toContain( + 'fixture:generate:all', + ) + expect(from(`${EQL_PACKAGE}/tasks/**`)).toContain('test:bench') + }) + + it('derives file-task names the way mise does', () => { + const names = [...TASKS.keys()] + // Extension dropped, directories joined with `:`. + expect(names).toContain('test:bench') + // No extension at all, and not under `tasks/test`. + expect(names).toContain('githooks:pre-commit') + // Only the LAST extension goes. + expect(names).toContain('release:prepare-bindings-assets.test') + // The collision case: `tasks/test/known-failures.sh` keeps its extension + // because `[tasks."test:known-failures"]` in mise.toml claimed the stem. + // Collapse these two and the file task silently replaces the TOML one, and + // `test:known-failures` — which test-eql.yml runs — resolves to a task with + // different content. + expect(names).toContain('test:known-failures.sh') + expect(TASKS.get('test:known-failures')?.source).toBe(MISE_TOML) + }) + + it('leaves non-executable files out of the task set', () => { + // The inclusion rule is the executable bit, nothing else. These four are + // mode 644 and are NOT tasks: two are `source`d by other scripts, one is + // invoked as `bash tasks/...` from a TOML task, one is data. A rule based + // on the `.sh` extension would wrongly promote all three scripts, and an + // allowlist of extensions would wrongly demote `githooks:pre-commit`. + const names = [...TASKS.keys()] + expect(names).not.toContain('build:ordering') // sourced by tasks/build.sh + expect(names).not.toContain('test:stub-fixtures') // sourced by 5 tasks + expect(names).not.toContain('test:sqlx-archive') // `bash tasks/...` + expect(names).not.toContain('test:symbol_order_allowlist') // a .txt + }) + + it('reads `depends` from both dialects', () => { + // TOML form. expect(TASKS.get('test:sqlx')?.depends).toEqual(['test:sqlx:prep']) + // `#MISE depends=[...]` header-comment form, which only file tasks use. Without + // it `docs:validate:source` — which test-eql.yml runs on every PR — stops + // being a caller of `build`. + expect(TASKS.get('docs:validate:source')?.depends).toEqual(['build']) }) - it('finds the tasks that invoke cargo, including through a script', () => { - // 19 today. The floor is set above the 15 that block-only parsing finds, so - // losing `scriptBodies` fails here rather than silently shrinking the set - // by the four tasks most worth checking. - expect(CARGO_TASKS.length).toBeGreaterThanOrEqual(18) + it('parses the whole graph, not a fragment of it', () => { + // 73 today, matching `mise tasks ls --hidden --json` name for name. A + // coarse net under the per-source checks above: it catches a shrinkage + // that leaves every source non-empty. + expect(TASKS.size).toBeGreaterThanOrEqual(70) + }) +}) + +describe('every cargo check EQL owns is reached by a root workflow', () => { + const reachable = reachableFrom(TASKS, rootWorkflows) - // The named case: `run = "bash tasks/test/sqlx-archive.sh"`. Nothing in the - // task block mentions cargo; `cargo nextest archive` is in the script. + it('finds the tasks that invoke cargo, including through a script', () => { + // 26 today. The floor sits above the 19 a mise.toml-only scan finds, so + // losing the file walk or an included config fails here rather than + // silently shrinking the set by the seven tasks it took to notice they + // were missing. + expect(CARGO_TASKS.length).toBeGreaterThanOrEqual(24) + + // One named case per parsing class, because the count alone cannot say + // WHICH class went missing: + // a TOML task whose cargo lives in a delegated script, expect(CARGO_TASKS).toContain('test:sqlx:archive') + // a FILE task (tasks/test/bench.sh — the class that made deleting + // bench-eql.yml invisible), + expect(CARGO_TASKS).toContain('test:bench') + // and a bare-table task in an included config. + expect(CARGO_TASKS).toContain('fixture:generate:all') }) it('distinguishes a task name from a longer task that starts with it', () => { - // The property `invokes` exists for. Without the trailing guard, + // The property the trailing guard in `invokes` exists for. Without it, // `test:sqlx` reads as reached by test-eql.yml's archive and partition // steps, and drops out of the exemption list silently. const body = 'run: mise run test:sqlx:archive\nrun: mise run test:schema\n' @@ -353,13 +741,67 @@ describe('every cargo check EQL owns is reached by a root workflow', () => { expect(invokes(body, 'test:schema')).toBe(true) }) - it('runs every cargo task, or names it as exempt with a reason', () => { - const orphans = CARGO_TASKS.filter( - (name) => !reachable.has(name) && !CI_EXEMPT_CARGO_TASKS.has(name), + it('counts a command and not a mention of one', () => { + // Every form below is real text from this tree. The three that must NOT + // count are the ones that made `test:sqlx` look reached. + expect(invokes(' mise run test:sqlx:prep\n', 'test:sqlx:prep')).toBe(true) + expect(invokes('mise run clean && mise run build\n', 'build')).toBe(true) + expect(invokes(' run: mise run test:crates\n', 'test:crates')).toBe( + true, ) + expect( + invokes( + 'mise run --output prefix test:bench --postgres 17\n', + 'test:bench', + ), + ).toBe(true) + + // A comment (tasks/fixtures.toml, on the fixture regeneration cadence). + expect( + invokes('# regenerated on every `mise run test:sqlx`\n', 'test:sqlx'), + ).toBe(false) + // Comment stripping is a SECOND line of defence, not a redundant one, and + // this case is what separates the two: the sentence puts `mise run` right + // after a `;`, which is a position COMMAND_START accepts. mise.toml is full + // of prose in this shape ("only WRITES the snapshots; `mise run + // test:matrix:inventory` is the gate"), and today every instance happens to + // carry a backtick that COMMAND_START rejects — an accident, not a rule. + expect( + invokes( + '# writes them; mise run test:matrix:inventory is the gate\n', + 'test:matrix:inventory', + ), + ).toBe(false) + // A diagnostic (tasks/codegen-parity.sh). + expect( + invokes( + `echo "surface is stale — run 'mise run build' and commit"\n`, + 'build', + ), + ).toBe(false) + // A real invocation and a quoted mention on ONE line (macro-expand-eql.yml + // shape). The first must count and the second must not. + const mixed = `mise run test:schema || { echo "run 'mise run test:sqlx' first"; }\n` + expect(invokes(mixed, 'test:schema')).toBe(true) + expect(invokes(mixed, 'test:sqlx')).toBe(false) + }) + + it('follows `mise run` inside a task body, not only `depends`', () => { + // `test:sqlx:prep` ends with `mise run fixture:generate:all`, and nothing + // declares that as a dependency. Under a depends-only closure the task that + // mints every SQLx fixture through ZeroKMS reads as unreached — an orphan + // that no workflow could ever clear, since no workflow names it. + expect(TASKS.get('test:sqlx:prep')?.depends).not.toContain( + 'fixture:generate:all', + ) + expect([...reachable]).toContain('fixture:generate:all') + }) + + it('runs every cargo task, or names it as exempt with a reason', () => { + const orphans = orphanCargoTasks(reachable) expect( orphans, - `These mise tasks invoke cargo and no workflow in ${WORKFLOW_DIR} reaches them, directly or through \`depends\`. A check nothing invokes reads exactly like a check that passes. Either add it to a workflow, or add it to CI_EXEMPT_CARGO_TASKS with the reason it does not belong in CI:\n${orphans + `These mise tasks invoke cargo and no workflow in ${WORKFLOW_DIR} reaches them, directly, through \`depends\`, or through a \`mise run\` in a task body. A check nothing invokes reads exactly like a check that passes. Either add it to a workflow, or add it to CI_EXEMPT_CARGO_TASKS with the reason it does not belong in CI:\n${orphans .map((name) => ` ${name}`) .join('\n')}`, ).toEqual([]) @@ -368,7 +810,8 @@ describe('every cargo check EQL owns is reached by a root workflow', () => { it('keeps no exemption for a task that is run, or has gone', () => { // Both directions. An exemption for a task CI now runs is noise that hides // the next one; an exemption for a task that no longer exists is a claim - // about nothing. + // about nothing. This is also what retires the `docs:generate:json` entry + // automatically once `_build-docs.yml` is ported to the repository root. const stale = [...CI_EXEMPT_CARGO_TASKS.keys()].filter( (name) => !TASKS.has(name) || reachable.has(name), ) @@ -379,6 +822,72 @@ describe('every cargo check EQL owns is reached by a root workflow', () => { }) }) +/** + * Workflows that are the SOLE caller of some cargo check. + * + * Deleting one of these silently removes coverage, which is the failure this + * whole file is about — so the list is written down, and the tests below drive + * the scan against a workflow set with each one removed to prove the guard + * actually fails. + */ +const SOLE_CALLER_WORKFLOWS = [ + `${WORKFLOW_DIR}/bench-eql.yml`, // test:bench + `${WORKFLOW_DIR}/macro-expand-eql.yml`, // test:matrix:expand + `${WORKFLOW_DIR}/test-eql.yml`, // most of the suite +] + +describe('the guard fails when a workflow stops calling a cargo check', () => { + /** + * The mutation is injected, not performed. Deleting `bench-eql.yml` from the + * working tree and re-running is what proved the ORIGINAL scan blind — all 14 + * assertions stayed green, because `test:bench` is a FILE task and file tasks + * were not parsed at all. Encoding that as a permanent test means passing a + * shorter workflow list to `reachableFrom`, which is the reason that function + * takes one rather than reading the directory. `lint-no-eql-registry-pins.mjs` + * splits `lint()` from `report()` for the same reason. + */ + const without = (relPath) => + rootWorkflows.filter((wf) => wf.relPath !== relPath) + + it('reports test:bench as an orphan when bench-eql.yml goes', () => { + const workflows = without(BENCH_WORKFLOW) + // The mutation has to actually remove something, or this proves nothing. + expect(workflows.length).toBe(rootWorkflows.length - 1) + + const orphans = orphanCargoTasks(reachableFrom(TASKS, workflows)) + expect( + orphans, + `Removing ${BENCH_WORKFLOW} left every cargo check accounted for, which means this file would not notice its deletion. \`test:bench\` (packages/eql/tasks/test/bench.sh, the cargo \`bench\`-feature SQLx suite) has no other caller, so it must be reported. If the bench suite genuinely moved to another workflow, update SOLE_CALLER_WORKFLOWS.`, + ).toContain('test:bench') + }) + + it('names every workflow whose deletion would orphan a cargo check', () => { + const soleCallers = rootWorkflows + .map(({ relPath }) => relPath) + .filter( + (relPath) => + orphanCargoTasks(reachableFrom(TASKS, without(relPath))).length > 0, + ) + + expect( + soleCallers, + `The set of workflows carrying EQL's only copy of some cargo check has changed.\n` + + 'GREW: a check that had a second caller now has one — expected if a job moved, but it means that file is now load-bearing.\n' + + "SHRANK: a workflow stopped being anyone's only caller. Either its checks moved elsewhere (fine, update this list) or it stopped running them (not fine).\n" + + 'A workflow dropping out because its checks now run NOWHERE cannot happen quietly — the orphan check above fails first.', + ).toEqual(SOLE_CALLER_WORKFLOWS) + }) + + it('is not vacuous: some workflow is load-bearing', () => { + // If every cargo check had two callers this whole describe block would pass + // by finding nothing, and so would a scan that parsed no tasks at all. + expect(SOLE_CALLER_WORKFLOWS.length).toBeGreaterThan(0) + expect(CARGO_TASKS.length).toBeGreaterThan( + CI_EXEMPT_CARGO_TASKS.size, // more cargo tasks run than are excused + ) + }) +}) + /** * What is still allowed to sit in the deposited `.github`, and why. * @@ -403,7 +912,7 @@ const UNPORTED_DEPOSIT = [ // until trusted publishing is repointed at cipherstash/stack. '.github/release.yml', // release-notes categorisation config, not a workflow '.github/workflows/README.md', // documents the four below - '.github/workflows/_build-docs.yml', + '.github/workflows/_build-docs.yml', // the sole caller of `docs:generate:json` '.github/workflows/_build-sql.yml', '.github/workflows/lint-release.yml', // actionlints the four below '.github/workflows/rebuild-docs.yml', diff --git a/scripts/__tests__/eql-workflow-filters.test.mjs b/scripts/__tests__/eql-workflow-filters.test.mjs new file mode 100644 index 000000000..9857314c5 --- /dev/null +++ b/scripts/__tests__/eql-workflow-filters.test.mjs @@ -0,0 +1,232 @@ +import { execFileSync } from 'node:child_process' +import yaml from 'js-yaml' +import { describe, expect, it } from 'vitest' +import { REPO_ROOT } from './lib/repo-root.mjs' +import { readWorkflow } from './lib/workflows.mjs' + +/** + * The two EQL workflows decide what to run from a list of path globs, and both + * lists are written by hand more than once. + * + * `test-eql.yml` writes its list TWICE and in two different mechanisms: an + * `on: push: paths:` filter (which decides whether the workflow starts at all + * after a merge) and a `dorny/paths-filter` `relevant:` filter (which decides + * whether the heavy jobs run inside a pull-request run). GitHub gives no way to + * share them. `bench-eql.yml` writes a third copy, for the same tree, on its own + * `push` trigger. + * + * Three properties, and each of them was violated by the imported files: + * + * 1. THE COPIES AGREE. Same argument as `workflow-paths-filter-parity.test.mjs` + * makes for the `push`/`pull_request` pair, one mechanism over: a filter that + * loses an entry keeps reporting green, and the run it stops starting is the + * one that would have caught the change. + * + * 2. NO GLOB IS DEAD. `packages/eql/sql/**` sat in the relevance filter from the + * port onward and there is no such directory — the SQL lives in + * `packages/eql/src/`. A glob that matches nothing narrows the filter by + * exactly nothing while reading, to anyone auditing coverage, as though that + * tree were covered. Compared against the real index, so a directory that is + * RENAMED fails here rather than quietly stopping being an input. + * + * 3. THE COMPOSITE ACTIONS ARE COVERED. Both workflows invoke + * `./.github/actions/require-cs-secrets`, whose job is to fail a credentialed + * run in seconds. Neither filter listed it, so an edit that broke the + * pre-flight ran in neither workflow. Discovered from each workflow's own + * `uses:` edges rather than named here, so a second local action is covered + * the day it is wired in. + * + * NOT COVERED, deliberately: whether the lists are COMPLETE. Nothing here can + * tell that `mise run postgres:up` reads `tests/docker-compose.yml`; that is + * read out of the task bodies by hand, and three such omissions are recorded in + * the comment above `bench-eql.yml`'s filter. What this file can guarantee is + * that the three lists stay one list, so the next such omission has to be made + * three times rather than once. + */ + +const TEST_EQL = '.github/workflows/test-eql.yml' +const BENCH_EQL = '.github/workflows/bench-eql.yml' + +/** `on:` parses as the boolean `true` under YAML 1.1 — the "Norway problem". */ +function triggers(wf) { + const on = wf?.on ?? wf?.[true] + return on && typeof on === 'object' ? on : {} +} + +/** A workflow's `on.push.paths` list, or `[]`. */ +function pushPaths(relPath) { + const paths = triggers(readWorkflow(relPath))?.push?.paths + return Array.isArray(paths) ? paths : [] +} + +/** + * Every path listed by a `dorny/paths-filter` step, across every filter it + * declares. `filters:` is a YAML document embedded in a YAML string, so it is + * parsed rather than pattern-matched — a regex over the raw block would also + * match the commentary around it. + */ +function dornyFilterPaths(relPath) { + const wf = readWorkflow(relPath) + return Object.values(wf?.jobs ?? {}) + .flatMap((job) => job?.steps ?? []) + .filter((step) => + String(step?.uses ?? '').startsWith('dorny/paths-filter@'), + ) + .flatMap((step) => + Object.values(yaml.load(step?.with?.filters ?? '') ?? {}), + ) + .flat() +} + +/** The local composite actions a workflow reaches through `uses: ./…`. */ +function localActions(relPath) { + const wf = readWorkflow(relPath) + return [ + ...new Set( + Object.values(wf?.jobs ?? {}) + .flatMap((job) => job?.steps ?? []) + .map((step) => String(step?.uses ?? '').trim()) + .filter((uses) => uses.startsWith('./.github/actions/')) + .map((uses) => uses.slice('./'.length)), + ), + ].sort() +} + +/** Files git tracks under a pathspec. */ +function trackedUnder(pathspec) { + return execFileSync('git', ['ls-files', '-z', '--', pathspec], { + cwd: REPO_ROOT, + encoding: 'utf8', + }) + .split('\0') + .filter(Boolean) +} + +/** + * Approximates picomatch, which is what `dorny/paths-filter` and GitHub's own + * `paths:` matcher are built on: `*` stops at a separator, `**` does not. + * + * No implicit-descendants tail here, unlike the `@actions/glob` approximation + * in `ffi-binding-action.test.mjs` — a bare directory name is NOT a prefix + * match in a `paths:` filter, which is the difference that makes a + * `.../require-cs-secrets` entry without its `/**` cover nothing. + */ +function globToRegExp(pattern) { + let source = '^' + for (let i = 0; i < pattern.length; i += 1) { + const ch = pattern[i] + if (ch === '*') { + if (pattern[i + 1] === '*') { + source += '.*' + i += 1 + if (pattern[i + 1] === '/') i += 1 + } else { + source += '[^/]*' + } + } else if (ch === '?') { + source += '[^/]' + } else { + source += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&') + } + } + return new RegExp(`${source}$`) +} + +const matches = (pattern, path) => globToRegExp(pattern).test(path) + +/** Everything in the index a filter entry could plausibly select. */ +const TRACKED = trackedUnder('.') + +/** The list each mechanism carries, keyed for the messages below. */ +const LISTS = [ + { id: `${TEST_EQL} (on.push.paths)`, entries: pushPaths(TEST_EQL) }, + { id: `${TEST_EQL} (dorny relevant:)`, entries: dornyFilterPaths(TEST_EQL) }, + { id: `${BENCH_EQL} (on.push.paths)`, entries: pushPaths(BENCH_EQL) }, +] + +/** + * The workflow file each list is allowed to name, and the only entry that may + * differ between them: a filter naming its own workflow is not a copy of the + * same claim, it is each file saying "and me". + */ +const SELF_REFERENCES = new Set([TEST_EQL, BENCH_EQL]) + +const shared = (entries) => + entries.filter((entry) => !SELF_REFERENCES.has(entry)).sort() + +describe('the EQL path filters are three copies of one list', () => { + it('finds all three lists', () => { + // Each check below is "these lists agree" or "no entry violates X", and an + // empty list satisfies both for free. The `dorny` one is the fragile + // member — its `filters:` is YAML inside a YAML string, so a reformat can + // empty it without failing anything else. + for (const { id, entries } of LISTS) { + expect( + entries, + `${id} parsed to an empty list, so every comparison below is vacuous for it. Either the filter moved, or the shape this file reads it out of changed.`, + ).not.toEqual([]) + } + }) + + it('names the same paths in every copy', () => { + const [reference, ...rest] = LISTS + for (const list of rest) { + expect( + shared(list.entries), + `The EQL path filters have diverged. ${list.id} and ${reference.id} answer the same question — "can this diff affect EQL?" — through mechanisms GitHub gives no way to share, so the list is written three times and nothing but this check keeps the copies together.\nThe silent direction is a DELETION from one copy: the workflows that still carry the entry keep running and keep reporting green, so the only signal is the run that stopped happening.\nIf a divergence is genuinely intended, it needs a different guard, not a wider one — the bench being a subset of the test suite's inputs is exactly the reasoning that produced the three drifted entries this list replaced.`, + ).toEqual(shared(reference.entries)) + } + }) + + for (const { id, entries } of LISTS) { + it(`${id} lists no glob that matches nothing`, () => { + const dead = entries.filter( + (entry) => !TRACKED.some((file) => matches(entry, file)), + ) + expect( + dead, + `These entries in ${id} match no file git tracks. A dead glob narrows the filter by nothing while reading as coverage of the tree it names — \`packages/eql/sql/**\` sat in this filter from the subtree import onward, and there is no such directory.\nEither fix the path, or delete the entry.`, + ).toEqual([]) + }) + } +}) + +describe('every composite action a workflow runs can trigger it', () => { + for (const relPath of [TEST_EQL, BENCH_EQL]) { + const actions = localActions(relPath) + + it(`${relPath} runs at least one local composite action`, () => { + // The scan guard. Both workflows use `require-cs-secrets` today; if the + // discovery stops seeing it, the coverage check below iterates nothing + // and passes. + expect( + actions, + `No step in ${relPath} runs a \`./.github/actions/…\` composite action, so the coverage check below compares nothing. Either the action was inlined, or the \`uses:\` shape changed.`, + ).not.toEqual([]) + }) + + it(`${relPath} triggers on a change to each of them`, () => { + // Every list this workflow gates on has to cover them: for test-eql that + // is the `push` filter AND the relevance filter, and an action edit that + // reached only one of the two would start the workflow and then skip + // every job inside it. + const lists = LISTS.filter((list) => list.id.startsWith(relPath)) + expect(lists.length).toBeGreaterThan(0) + + const uncovered = lists.flatMap(({ id, entries }) => + actions + .filter( + (action) => + !trackedUnder(action).every((file) => + entries.some((entry) => matches(entry, file)), + ), + ) + .map((action) => `${id} does not cover ${action}`), + ) + expect( + uncovered, + `${relPath} runs these composite actions and does not trigger on a change to them. \`require-cs-secrets\` is the pre-flight that turns a rotated credential into a failure in seconds rather than one four minutes into a compile — an edit that breaks it must run the workflows that depend on it.\nAdd \`/**\` to every filter listed.`, + ).toEqual([]) + }) + } +}) diff --git a/scripts/__tests__/ffi-binding-action.test.mjs b/scripts/__tests__/ffi-binding-action.test.mjs index a50b4b574..a4a8076b4 100644 --- a/scripts/__tests__/ffi-binding-action.test.mjs +++ b/scripts/__tests__/ffi-binding-action.test.mjs @@ -38,7 +38,7 @@ */ import { execFileSync } from 'node:child_process' import { existsSync, readFileSync, statSync } from 'node:fs' -import { dirname, join, resolve } from 'node:path' +import { dirname, join, relative, resolve } from 'node:path' import yaml from 'js-yaml' import { describe, expect, it } from 'vitest' import { readJsonc } from './lib/read-jsonc.mjs' @@ -354,6 +354,259 @@ describe('build-ffi-binding — the WASM key covers the build it skips', () => { }) }) +/** + * The third question a cache key has to answer, and the one the two suites + * above cannot see: does it cover every crate the build COMPILES? + * + * Both of those reason about files inside `packages/protect-ffi`. Cargo does + * not. `crates/protect-ffi/Cargo.toml` carries + * + * eql-bindings = { path = "../../../eql/crates/eql-bindings" } + * + * — an in-tree path dependency in a DIFFERENT package, and a genuine compile + * input to both `index.node` and the wasm32 build. A path dep carries no + * registry checksum, so a src-only edit under that crate touches nothing else: + * not `packages/protect-ffi/crates/**`, not either `Cargo.toml`, and not + * `Cargo.lock` (which records the path dep by name and version, and only moves + * when the version does). Every glob in both keys therefore hashes identically, + * the restore hits, `Build index.node (cargo)` is SKIPPED, and every + * credentialed job in CI proceeds on a binding compiled from the old crate. + * + * That is not hypothetical: across the three commits that shipped this + * dependency the crate's version moved 3.0.4 -> 4.0.0 -> 3.0.5 and neither + * cache key changed by a byte. + * + * DISCOVERED, not listed. The dependency set is read out of the manifest and + * followed transitively, so the second path dep — or one that moves — is held + * to the same bar the day it lands. A hand-written list would have been right + * on the commit that added it and silently wrong afterwards, which is the same + * failure shape one level down. + * + * `[dev-dependencies]` are deliberately NOT followed. `build:native` is + * `cargo build --release` and `build:wasm` is wasm-pack; neither compiles a + * dependency's dev-deps, so requiring them in the key would bust the cache on + * edits that cannot reach the artifact. (`eql-bindings` has one — `eql-domains`, + * its parity oracle — so this is a live distinction, not a hypothetical.) + */ + +const CARGO_ROOT_CRATE = `${FFI_PKG}/crates/protect-ffi/Cargo.toml` + +/** + * The path dependencies declared by one Cargo manifest, as `{ name, path }` + * with `path` exactly as written. + * + * Deliberately a narrow reader over the text rather than a TOML parse: there is + * no TOML parser in this repo's dependency tree, and `cargo metadata` would put + * a Rust toolchain on `pnpm test:scripts` — which `packages/protect-ffi`'s + * `lintWiring.test.ts` exists to keep off the JS entry points. + * + * It reads both spellings cargo accepts: the inline table + * (`foo = { path = "..." }`) and the section form (`[dependencies.foo]` with a + * `path =` line beneath it). Sections are matched by their TAIL, so + * `[target.'cfg(not(target_arch = "wasm32"))'.dependencies]` is read the same + * as `[dependencies]` — the wasm and native halves of this crate declare + * different dependency sets and both compile. + * + * Exported shape is a pure function of the text so `the manifest reader is + * sound` below can exercise it on a literal, rather than on whatever the real + * manifest happens to say today. + */ +function parsePathDependencies(text) { + const found = [] + let section = null + for (const raw of text.split('\n')) { + const line = raw.replace(/#.*$/, '').trim() + if (line === '') continue + + const header = /^\[([^\]]+)\]$/.exec(line) + if (header) { + section = header[1] + continue + } + if (section === null) continue + + // `[dependencies]`, `[build-dependencies]`, `[target.'…'.dependencies]`. + // `dev-dependencies` is excluded — see the note above the describe. + const isDepTable = /(^|\.)(build-)?dependencies$/.test(section) + // `[dependencies.foo]` / `[target.'…'.dependencies.foo]` + const namedDep = /(^|\.)(build-)?dependencies\.([A-Za-z0-9_-]+)$/.exec( + section, + ) + + if (isDepTable) { + const inline = /^([A-Za-z0-9_-]+)\s*=\s*\{(.*)\}$/.exec(line) + if (!inline) continue + const path = /\bpath\s*=\s*"([^"]+)"/.exec(inline[2]) + if (path) found.push({ name: inline[1], path: path[1] }) + } else if (namedDep) { + const path = /^path\s*=\s*"([^"]+)"$/.exec(line) + if (path) found.push({ name: namedDep[3], path: path[1] }) + } + } + return found +} + +/** + * Every crate `cargo build` compiles into the artifact, as repo-relative + * directories, starting from the cdylib crate and following path deps + * transitively. The starting crate itself is excluded: it lives under + * `packages/protect-ffi/crates/**`, which both keys already hash. + */ +function compiledPathDependencies(rootManifestRel) { + const crates = new Map() + const unresolved = [] + const queue = [rootManifestRel] + const seen = new Set([rootManifestRel]) + + while (queue.length > 0) { + const manifestRel = queue.shift() + const full = resolve(REPO_ROOT, manifestRel) + if (!existsSync(full)) { + unresolved.push(manifestRel) + continue + } + for (const dep of parsePathDependencies(readFileSync(full, 'utf8'))) { + const dirRel = relative( + REPO_ROOT, + resolve(dirname(full), dep.path), + ).replaceAll('\\', '/') + const depManifest = `${dirRel}/Cargo.toml` + if (!crates.has(dirRel)) crates.set(dirRel, dep.name) + if (seen.has(depManifest)) continue + seen.add(depManifest) + queue.push(depManifest) + } + } + return { + crates: [...crates.entries()].map(([dir, name]) => ({ dir, name })), + unresolved, + } +} + +/** + * The nearest ancestor manifest declaring `[workspace]` — the file cargo reads + * for the crate's workspace context, and the one a `foo.workspace = true` key + * inherits from. `eql-bindings` inherits nothing today, and three of its four + * siblings inherit `[lints]`, so the file is one `workspace = true` away from + * being a compile input for this crate too. + */ +function workspaceRootOf(dirRel) { + let current = dirRel + while (current !== '' && current !== '.') { + const candidate = `${current}/Cargo.toml` + const full = resolve(REPO_ROOT, candidate) + if ( + existsSync(full) && + /^\s*\[workspace\]/m.test(readFileSync(full, 'utf8')) + ) { + return candidate + } + current = dirname(current) + } + return null +} + +const COMPILED = compiledPathDependencies(CARGO_ROOT_CRATE) + +/** Which of this action's cache steps must cover a Rust compile input. */ +const RUST_CACHE_STEPS = cacheSteps.map((step, idx) => ({ + step, + name: label(step, idx), +})) + +describe('build-ffi-binding — the keys cover every crate the build compiles', () => { + it('the manifest reader is sound', () => { + // The discovery below is only as good as this. An over-accepting reader + // that returned nothing would make every check that follows vacuous, and a + // reader that missed the `[target.'cfg(…)'.dependencies]` form would miss + // exactly the half of this crate that only the wasm build compiles. + const deps = parsePathDependencies(` + [package] + name = "example" + path = "not-a-dependency" + + [dependencies] + registry-only = "1.0" + inline = { path = "../inline", version = "1" } + + [dev-dependencies] + oracle = { path = "../oracle" } + + [build-dependencies] + codegen = { path = "../codegen" } + + [target.'cfg(not(target_arch = "wasm32"))'.dependencies] + native = { path = "../native" } + + [dependencies.sectioned] + path = "../sectioned" + `) + expect(deps).toEqual([ + { name: 'inline', path: '../inline' }, + { name: 'codegen', path: '../codegen' }, + { name: 'native', path: '../native' }, + { name: 'sectioned', path: '../sectioned' }, + ]) + }) + + it('found the path dependencies it means to check', () => { + expect( + COMPILED.unresolved, + `These manifests are named by a \`path = \` dependency and do not exist. A path dep cargo cannot resolve does not build at all, so this is a broken manifest rather than a broken guard.`, + ).toEqual([]) + + expect( + COMPILED.crates.map((crate) => crate.dir), + `\`${CARGO_ROOT_CRATE}\` declares no path dependencies, so every assertion below iterates nothing and passes having checked nothing. If the in-tree crate moved to a registry pin, this guard is obsolete — but read \`scripts/lint-no-eql-registry-pins.mjs\` first, which exists to stop exactly that.`, + ).not.toEqual([]) + + for (const crate of COMPILED.crates) { + expect( + trackedUnder(crate.dir).length, + `${crate.dir} (\`${crate.name}\`) has no git-tracked files, so the coverage check below has nothing to compare against.`, + ).toBeGreaterThan(0) + } + }) + + for (const { step, name } of RUST_CACHE_STEPS) { + it(`"${name}" hashes every crate the build compiles`, () => { + const patterns = hashFilesPatterns(step?.with?.key) + const uncovered = COMPILED.crates.flatMap((crate) => + trackedUnder(crate.dir).filter( + (file) => !patterns.some((pattern) => globMatches(pattern, file)), + ), + ) + expect( + uncovered, + `These files are compiled into the artifact this step caches and are absent from its key, so an edit to one leaves the key unchanged, the restore hits, and the build step is skipped over a stale binary. A path dependency carries no registry checksum and does not move \`Cargo.lock\` on a source-only edit, so nothing else in the key covers it either.\nAdd a glob for each crate to the \`hashFiles(...)\` list on the "${name}" step.`, + ).toEqual([]) + }) + + it(`"${name}" hashes the workspace root of every out-of-tree crate`, () => { + const patterns = hashFilesPatterns(step?.with?.key) + const roots = [ + ...new Set( + COMPILED.crates + .map((crate) => workspaceRootOf(crate.dir)) + .filter(Boolean), + ), + ] + expect( + roots, + 'No path dependency resolved to a crate inside a Cargo workspace, so this check compares nothing.', + ).not.toEqual([]) + + const uncovered = roots.filter( + (root) => !patterns.some((pattern) => globMatches(pattern, root)), + ) + expect( + uncovered, + `Cargo reads these workspace manifests to resolve the path dependencies above — a \`.workspace = true\` in a dependency crate inherits from here, and \`[patch]\` is read from here too. They are build inputs on the same footing as the crate sources, and neither is covered by \`${FFI_PKG}\`'s own manifests.\nAdd each to the \`hashFiles(...)\` list on the "${name}" step.`, + ).toEqual([]) + }) + } +}) + describe('jdx/mise-action is pinned to an immutable commit', () => { const files = [ACTION, RUST_WORKFLOW] diff --git a/scripts/__tests__/frozen-publisher-docs.test.mjs b/scripts/__tests__/frozen-publisher-docs.test.mjs new file mode 100644 index 000000000..843d73959 --- /dev/null +++ b/scripts/__tests__/frozen-publisher-docs.test.mjs @@ -0,0 +1,93 @@ +import { readFileSync } from 'node:fs' +import { join } from 'node:path' +import { describe, expect, it } from 'vitest' +import { FROZEN_PUBLISHERS } from '../release-gate.mjs' +import { REPO_ROOT } from './lib/repo-root.mjs' + +/** + * `FROZEN_PUBLISHERS` is described in prose in two places, and the prose is + * what an agent reads before it decides whether a red `release:gate` is news. + * + * Both halves of that had already drifted. + * + * AGENTS.md asserted a LIVE VERDICT — "It fires today on the hand-applied 3.0.5 + * bump … and it blocks the Version Packages PR as well as the publish" — which + * stopped being true the moment `@cipherstash/eql@3.0.5` reached npm. The gate + * now exits 0 ("nothing to publish"). A durable instruction that tells an agent + * to expect a red gate is worse than no instruction: it turns a real blocker + * into an expected one, and the agent stops looking. + * + * That is the class this guard covers. A gate verdict is computed from the + * registry at run time, so it belongs in the gate's output, not in a checked-in + * sentence — the docs should state the CONDITION under which it fires and point + * at `node scripts/release-gate.mjs` for the answer. + * + * The second half is the deletion that is already scheduled. Phase 5 removes + * the `@cipherstash/eql` entry from the map, and on that day both documents + * become wrong in the other direction — still instructing agents about a freeze + * that no longer exists. Keyed on the map rather than on a date, so the cutover + * PR cannot land the code change without the prose. + */ + +const EQL = '@cipherstash/eql' + +/** Where the freeze is explained, and the instruction each file carries. */ +const DOCS = [ + { + file: 'AGENTS.md', + // Both spellings resolve to "the `@cipherstash/eql` entry", which is the + // thing Phase 5 deletes — matching that keeps the guard anchored to the + // instruction rather than to a paragraph that may be rewritten. + instruction: /`@cipherstash\/eql` entry/, + }, + { + file: 'docs/plans/2026-08-13-eql-monorepo-absorption.md', + instruction: /`@cipherstash\/eql` entry/, + }, +] + +/** + * Present-tense assertions that the gate is CURRENTLY blocking. Not a style + * rule — each of these was true when written and false by the next merge, and + * neither has any way to notice. + */ +const LIVE_VERDICT_CLAIMS = [ + /\bfires today\b/, + /\bblocks the Version Packages PR\b/, + /\bcatches the hand-applied 3\.0\.5 bump\b/, +] + +const read = (file) => readFileSync(join(REPO_ROOT, file), 'utf8') + +describe('frozen-publisher docs track the map', () => { + it('still has a frozen entry to document', () => { + // The map going empty is the Phase-5 end state and a legitimate one — but + // it must arrive with the doc edits below, not ahead of them. An empty map + // here means every `iff` assertion is vacuous, so say so out loud. + expect(FROZEN_PUBLISHERS.size).toBeGreaterThan(0) + }) + + it.each(DOCS)('$file documents the eql freeze iff the map carries it', ({ + file, + instruction, + }) => { + expect( + instruction.test(read(file)), + FROZEN_PUBLISHERS.has(EQL) + ? `${file} no longer tells an agent about the ${EQL} freeze, but ` + + 'FROZEN_PUBLISHERS still carries it.' + : `${EQL} has left FROZEN_PUBLISHERS (Phase-5 cutover), so ${file} ` + + 'must stop instructing agents about the freeze.', + ).toBe(FROZEN_PUBLISHERS.has(EQL)) + }) + + it.each(DOCS)('$file asserts no live gate verdict', ({ file }) => { + const body = read(file) + expect( + LIVE_VERDICT_CLAIMS.filter((claim) => claim.test(body)).map(String), + `${file} states what release-gate currently does. That is decided by the ` + + 'registry at run time — describe the condition and point at ' + + '`node scripts/release-gate.mjs` instead.', + ).toEqual([]) + }) +}) diff --git a/scripts/__tests__/lint-no-eql-registry-pins.test.mjs b/scripts/__tests__/lint-no-eql-registry-pins.test.mjs index 06373c111..21e570f45 100644 --- a/scripts/__tests__/lint-no-eql-registry-pins.test.mjs +++ b/scripts/__tests__/lint-no-eql-registry-pins.test.mjs @@ -9,10 +9,12 @@ import { declarationId, EXEMPT_DECLARATIONS, EXPECTED_DECLARERS, + EXPECTED_SOURCES, lint, manifestFiles, npmDeclarations, report, + workspaceDeclarations, } from '../lint-no-eql-registry-pins.mjs' import { REPO_ROOT } from './lib/repo-root.mjs' import { readWorkflow, workflowFiles } from './lib/workflows.mjs' @@ -284,6 +286,325 @@ describe('npm: what counts as in-tree', () => { }) }) +describe('npm: the spellings a name-keyed scan walks past', () => { + const pkg = (json) => npmDeclarations('package.json', JSON.stringify(json)) + + it('reads a NESTED npm override', () => { + // npm's overrides are a tree, not a flat map: this pins EQL only under + // `some-pkg`, and a scan that reads `overrides['@cipherstash/eql']` sees an + // empty result and reports the tree clean. + const found = pkg({ + overrides: { 'some-pkg': { '@cipherstash/eql': '3.0.4' } }, + }) + expect(found).toHaveLength(1) + expect(found[0]).toMatchObject({ + table: 'overrides.some-pkg', + spec: '3.0.4', + inTree: false, + }) + }) + + it('reads an override nested more than one level deep', () => { + expect( + pkg({ + overrides: { a: { b: { '@cipherstash/eql': '3.0.4' } } }, + })[0], + ).toMatchObject({ table: 'overrides.a.b', inTree: false }) + }) + + it("reads npm's `.` self-target spelling", () => { + // `{"@cipherstash/eql": {".": "3.0.4"}}` pins the package itself and scopes + // further overrides beneath it. The version is on the CHILD key. + expect( + pkg({ overrides: { '@cipherstash/eql': { '.': '3.0.4' } } })[0], + ).toMatchObject({ spec: '3.0.4', inTree: false }) + }) + + it("reads pnpm's `parent>child` override selector", () => { + expect( + pkg({ pnpm: { overrides: { 'some-pkg>@cipherstash/eql': '3.0.4' } } })[0], + ).toMatchObject({ table: 'pnpm.overrides', inTree: false }) + }) + + it('reads an override key carrying a version selector', () => { + expect( + pkg({ pnpm: { overrides: { '@cipherstash/eql@<3.0.5': '3.0.4' } } })[0], + ).toMatchObject({ inTree: false }) + }) + + it("reads yarn's `**/` resolutions glob", () => { + expect( + pkg({ resolutions: { '**/@cipherstash/eql': '3.0.4' } })[0], + ).toMatchObject({ table: 'resolutions', inTree: false }) + }) + + it('does not flag a neighbouring package whose name starts the same', () => { + // `@cipherstash/eql-extras` is not `@cipherstash/eql`. A prefix match here + // makes the linter cry wolf, and the fix for a linter that cries wolf is + // always to weaken it. + expect( + pkg({ dependencies: { '@cipherstash/eql-extras': '1.0.0' } }), + ).toEqual([]) + expect( + pkg({ overrides: { other: { '@cipherstash/eqlx': '3.0.4' } } }), + ).toEqual([]) + }) + + it('reads a RENAMED dependency whose value aliases the package', () => { + // The name is on the right-hand side. Keying the scan on the dependency + // name misses this entirely — it installs @cipherstash/eql@3.0.4 from the + // registry under another name. + const found = pkg({ + dependencies: { 'eql-legacy': 'npm:@cipherstash/eql@3.0.4' }, + }) + expect(found).toHaveLength(1) + expect(found[0]).toMatchObject({ + key: 'eql-legacy', + form: 'alias', + inTree: false, + }) + }) + + it('accepts the in-tree spelling of an alias', () => { + // `workspace:@` is how an aliased dep names a workspace + // package. It resolves in-tree, so it is not an offender. + expect( + pkg({ + dependencies: { 'eql-legacy': 'workspace:@cipherstash/eql@^' }, + })[0], + ).toMatchObject({ inTree: true, form: 'workspace' }) + }) + + it('ignores an alias pointing at some other package', () => { + expect(pkg({ dependencies: { x: 'npm:lodash@4' } })).toEqual([]) + }) + + it('reads an alias hidden in an override', () => { + expect( + pkg({ overrides: { 'eql-legacy': 'npm:@cipherstash/eql@3.0.4' } })[0], + ).toMatchObject({ form: 'alias', inTree: false }) + }) + + it('names the declaration by the package, not by the key it was found under', () => { + // `EXPECTED_DECLARERS` and `EXEMPT_DECLARATIONS` are keyed ` :: + // `. If an alias were filed under its alias name, an exemption + // could never be written for it and the two lists would drift apart from + // the scan. + expect( + declarationId( + pkg({ + dependencies: { 'eql-legacy': 'npm:@cipherstash/eql@3.0.4' }, + })[0], + ), + ).toBe('package.json :: @cipherstash/eql') + }) + + it('reports the offending KEY, so the reader can find the line', () => { + const { code, err } = report({ + ids: ['x :: y'], + declarations: [], + exempted: [], + staleExemptions: [], + unreasonedExemptions: [], + missingExpected: [], + missingSources: [], + offenders: [ + { + file: 'package.json', + dependency: '@cipherstash/eql', + key: 'eql-legacy', + table: 'dependencies', + spec: 'npm:@cipherstash/eql@3.0.4', + }, + ], + }) + expect(code).toBe(1) + expect(err).toContain('eql-legacy') + }) + + it('flags a nested override end to end', () => { + const root = tree({ + 'package.json': '{"overrides":{"some-pkg":{"@cipherstash/eql":"3.0.4"}}}', + }) + expect(run(root).exitCode).toBe(1) + }) +}) + +describe('pnpm-workspace.yaml: the file no manifest scan opens', () => { + const declarations = (yaml) => + workspaceDeclarations('pnpm-workspace.yaml', yaml) + + it('is collected by the walk', () => { + // The hole this whole block is about: pnpm 10 reads `overrides` from here, + // and the scan only ever opened `Cargo.toml` and `package.json`. + const root = tree({ 'pnpm-workspace.yaml': 'packages:\n - packages/*\n' }) + expect(manifestFiles(root)).toContain('pnpm-workspace.yaml') + }) + + it('reads a top-level `overrides:` entry', () => { + expect( + declarations("overrides:\n '@cipherstash/eql': 3.0.4\n")[0], + ).toMatchObject({ + file: 'pnpm-workspace.yaml', + dependency: '@cipherstash/eql', + table: 'overrides', + spec: '3.0.4', + inTree: false, + }) + }) + + it('reads an override written as a version selector', () => { + // The shape every other override in this repo's file is written in. + expect( + declarations("overrides:\n '@cipherstash/eql@<3.0.5': 3.0.4\n"), + ).toHaveLength(1) + }) + + it('reads a `parent>child` override', () => { + expect( + declarations("overrides:\n 'stash>@cipherstash/eql': 3.0.4\n"), + ).toHaveLength(1) + }) + + it('accepts a `workspace:` override', () => { + expect( + declarations("overrides:\n '@cipherstash/eql': workspace:^\n")[0], + ).toMatchObject({ inTree: true }) + }) + + it('reads a named catalog entry', () => { + // A catalog is the other way to move what installs: every manifest keeps + // saying `catalog:repo` while the version behind it changes here. + expect( + declarations("catalogs:\n repo:\n '@cipherstash/eql': 3.0.4\n")[0], + ).toMatchObject({ table: 'catalogs.repo', spec: '3.0.4', inTree: false }) + }) + + it('reads the default catalog', () => { + expect( + declarations("catalog:\n '@cipherstash/eql': 3.0.4\n")[0], + ).toMatchObject({ table: 'catalog', inTree: false }) + }) + + it('leaves the rest of the file alone', () => { + // The real file carries a dozen security overrides and two catalogs. A + // reader that flagged any of them would be turned off within the week. + expect( + declarations( + [ + 'packages:', + ' - packages/*', + 'catalogs:', + ' repo:', + ' typescript: 5.9.3', + 'overrides:', + " 'next@<15.5.18': '~15.5.18'", + " 'lodash@<4.18.0': '^4.18.0'", + 'minimumReleaseAge: 10080', + ].join('\n'), + ), + ).toEqual([]) + }) + + it('flags a workspace-level override end to end', () => { + // The mutation check, as a test: plant the pin the linter could not see + // and confirm it now exits 1. + const root = tree({ + 'pnpm-workspace.yaml': + "packages:\n - packages/*\noverrides:\n '@cipherstash/eql': 3.0.4\n", + 'packages/a/package.json': + '{"dependencies":{"@cipherstash/eql":"workspace:^"}}', + }) + expect(run(root).exitCode).toBe(1) + expect(run(root).output).toContain('pnpm-workspace.yaml') + }) + + it('flags a catalog entry end to end', () => { + const root = tree({ + 'pnpm-workspace.yaml': + "packages:\n - packages/*\ncatalogs:\n repo:\n '@cipherstash/eql': 3.0.4\n", + }) + expect(run(root).exitCode).toBe(1) + }) + + it('treats `catalog:` in a manifest as a registry pin, not as a deferral', () => { + // Cargo's `workspace = true` is accepted because the workspace root's entry + // is scanned as a declaration in its own right. `catalog:` is NOT given the + // same treatment: a catalog holds version ranges, so the deferral has no + // in-tree answer to defer to. Flagging both ends is deliberate. + expect( + npmDeclarations( + 'package.json', + '{"dependencies":{"@cipherstash/eql":"catalog:repo"}}', + )[0], + ).toMatchObject({ inTree: false, form: 'catalog' }) + }) +}) + +describe('the new source has a floor of its own', () => { + it('is satisfied by the real tree', () => { + expect(lint().missingSources).toEqual([]) + // And the floor needs a floor, for the same reason EXPECTED_DECLARERS does: + // an emptied list satisfies "nothing missing" trivially. + expect(EXPECTED_SOURCES).toContain('pnpm-workspace.yaml') + }) + + it('notices a source that is not there at all', () => { + const root = tree({ 'packages/a/package.json': '{"dependencies":{}}' }) + expect( + lint({ root, expected: [], exemptions: new Map() }).missingSources, + ).toEqual(['pnpm-workspace.yaml']) + }) + + it('notices a source that did not parse, rather than reading it as clean', () => { + // The failure mode this floor exists for. A YAML file that js-yaml refuses + // contributes no declarations — which is indistinguishable from a file with + // no overrides in it, and one of those two is a linter that stopped working. + const root = tree({ + 'pnpm-workspace.yaml': 'packages:\n - a\n bad indent: [\n', + }) + expect( + lint({ root, expected: [], exemptions: new Map() }).missingSources, + ).toEqual(['pnpm-workspace.yaml']) + }) + + it('notices a source emptied out', () => { + const root = tree({ 'pnpm-workspace.yaml': '\n# nothing here\n' }) + expect( + lint({ root, expected: [], exemptions: new Map() }).missingSources, + ).toEqual(['pnpm-workspace.yaml']) + }) + + it('exits 2 — not 0 — when a source could not be read', () => { + const { code, err } = report({ + ids: [], + declarations: [], + offenders: [], + exempted: [], + staleExemptions: [], + unreasonedExemptions: [], + missingExpected: [], + missingSources: ['pnpm-workspace.yaml'], + }) + expect(code).toBe(2) + expect(err).toContain('pnpm-workspace.yaml') + }) + + it('reports an unreadable source ahead of any offender it found', () => { + const { code } = report({ + ids: ['x :: y'], + declarations: [], + offenders: [{ file: 'a', dependency: 'b', spec: '"1.0"' }], + exempted: [], + staleExemptions: [], + unreasonedExemptions: [], + missingExpected: [], + missingSources: ['pnpm-workspace.yaml'], + }) + expect(code).toBe(2) + }) +}) + describe('the scan reports what it finds', () => { it('flags a registry pin anywhere in a tree', () => { const root = tree({ @@ -334,6 +655,7 @@ describe('the linter fails when its own configuration goes stale', () => { staleExemptions: [], unreasonedExemptions: [], missingExpected: [], + missingSources: [], } it('exits 2 — not 1 — when an expected declarer disappears', () => { diff --git a/scripts/__tests__/release-gate.test.mjs b/scripts/__tests__/release-gate.test.mjs index 992ea11cc..a2ae18255 100644 --- a/scripts/__tests__/release-gate.test.mjs +++ b/scripts/__tests__/release-gate.test.mjs @@ -1,13 +1,26 @@ -import { readFileSync } from 'node:fs' +import { spawnSync } from 'node:child_process' +import { + chmodSync, + mkdtempSync, + readFileSync, + rmSync, + writeFileSync, +} from 'node:fs' +import { tmpdir } from 'node:os' import { join } from 'node:path' import yaml from 'js-yaml' import { describe, expect, it } from 'vitest' import { classify, + packedRange, + publishBlockers, + satisfies, unpublished, + workspaceManifests, workspacePackagePatterns, } from '../release-gate.mjs' import { REPO_ROOT } from './lib/repo-root.mjs' +import { readWorkflow } from './lib/workflows.mjs' /** * The gate decides what a push to `main` still has to publish, and it is @@ -174,3 +187,461 @@ describe('classify', () => { expect(classify([])).toEqual({ ffi: false, js: false }) }) }) + +/** + * WHAT ARMS A RELEASE THAT CANNOT SUCCEED. + * + * `changeset publish` publishes every public workspace package whose committed + * version is absent from npm — changeset or no changeset. In the installed + * 2.31.0 it does that with no dependency ordering (`Promise.all`) and + * `publishAPackage` RETURNS a result rather than throwing, so one package's + * failed publish does not stop its siblings. A package that cannot publish + * therefore does not abort the release; it just does not arrive, and everything + * that depends on it ships pointing at a version nobody can install. + * + * That is not hypothetical here. `@cipherstash/eql` was hand-bumped to 3.0.5 in + * the workspace while npm's newest is 3.0.4 and its trusted publisher still + * names `cipherstash/encrypt-query-language` — so its publish from this + * repository is rejected, while `packages/cli` and `packages/stack-prisma` + * carry `"@cipherstash/eql": "workspace:^"` in their RUNTIME dependencies, + * which pnpm rewrites to `^3.0.5` at pack time. A range no published version + * satisfies, in a tarball that publishes fine. + */ + +const EQL = '@cipherstash/eql' + +describe('packedRange', () => { + it('resolves the three bare protocol forms the way pnpm does', () => { + // `workspace:*` is an EXACT pin, not a wildcard — the distinction the whole + // check turns on, since it makes the range unsatisfiable by anything but + // the one version. + expect(packedRange('workspace:*', '1.5.0')).toBe('1.5.0') + expect(packedRange('workspace:^', '1.5.0')).toBe('^1.5.0') + expect(packedRange('workspace:~', '1.5.0')).toBe('~1.5.0') + }) + + it('passes an explicit range through verbatim', () => { + expect(packedRange('workspace:^1.0.0', '1.5.0')).toBe('^1.0.0') + expect(packedRange('workspace:1.2.3', '1.5.0')).toBe('1.2.3') + }) + + it('ignores a specifier that is not the workspace protocol', () => { + // Registry ranges are somebody else's problem: npm resolves them itself. + expect(packedRange('^1.0.0', '1.5.0')).toBeNull() + expect(packedRange('catalog:repo', '1.5.0')).toBeNull() + }) +}) + +describe('satisfies', () => { + it('reads an exact pin', () => { + expect(satisfies('1.5.0', '1.5.0')).toBe(true) + expect(satisfies('1.5.1', '1.5.0')).toBe(false) + }) + + it('reads caret, including the 0.x and 0.0.x narrowings', () => { + expect(satisfies('1.9.9', '^1.5.0')).toBe(true) + expect(satisfies('2.0.0', '^1.5.0')).toBe(false) + expect(satisfies('1.4.9', '^1.5.0')).toBe(false) + // ^0.5.0 does NOT admit 0.6.0 — the case that decides whether + // `@cipherstash/protect-ffi@0.31.0`'s siblings are read correctly. + expect(satisfies('0.5.9', '^0.5.0')).toBe(true) + expect(satisfies('0.6.0', '^0.5.0')).toBe(false) + expect(satisfies('0.0.4', '^0.0.3')).toBe(false) + }) + + it('reads tilde', () => { + expect(satisfies('1.5.9', '~1.5.0')).toBe(true) + expect(satisfies('1.6.0', '~1.5.0')).toBe(false) + }) + + it('does not let a prerelease satisfy a stable range', () => { + // THE ONE THAT DECIDES THIS REPO'S ANSWER. npm carries + // `@cipherstash/eql@3.0.0-alpha.2` and friends, and a naive comparison puts + // some of them inside `^3.0.5`'s window — which would report the range as + // satisfiable and wave the whole defect through. + expect(satisfies('3.1.0-alpha.1', '^3.0.5')).toBe(false) + expect(satisfies('3.0.0-alpha.2', '^3.0.0')).toBe(false) + // …while a prerelease of the range's OWN tuple still counts, per semver. + expect(satisfies('3.0.5-rc.2', '^3.0.5-rc.1')).toBe(true) + }) + + it('throws on a range it cannot read, rather than guessing', () => { + // Every failure mode in this file fails loudly — see the script header. A + // range read as "unsatisfiable" would freeze a release that is fine; one + // read as "satisfiable" would publish the broken tarball. + expect(() => satisfies('1.0.0', '>=1.0.0 <2.0.0')).toThrow(/range/i) + expect(() => satisfies('1.0.0', '1.x')).toThrow(/range/i) + }) +}) + +describe('publishBlockers', () => { + /** A registry where nothing has ever been published. */ + const empty = () => null + + it('blocks a frozen package whose committed version is not on npm', () => { + // CHECK A. `changeset publish` will attempt this package because its + // version is absent, and the attempt is rejected — npm trusted publishing + // is bound to a repository, and this one is not it. + const blockers = publishBlockers({ + manifests: [ + { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] }, + ], + lookup: () => ['3.0.4'], + frozen: new Map([[EQL, 'publisher not repointed yet']]), + }) + expect(blockers.map((b) => b.kind)).toEqual(['frozen-publisher']) + expect(blockers[0].package).toBe(EQL) + }) + + it('lets a frozen package through once its committed version IS on npm', () => { + // The state the seven protect-ffi packages are in, and the unstated + // assumption `scripts/lint-no-ffi-changeset.mjs` rests on: at the published + // version, `changeset publish` skips them and the frozen publisher never + // matters. This is that assumption, checked. + expect( + publishBlockers({ + manifests: [ + { name: EQL, version: '3.0.4', private: false, workspaceDeps: [] }, + ], + lookup: () => ['3.0.4'], + frozen: new Map([[EQL, 'publisher not repointed yet']]), + }), + ).toEqual([]) + }) + + it('blocks a runtime range that only a frozen package could satisfy', () => { + // CHECK B, and the blast radius. `stash` publishes fine; it just ships a + // dependency on a version that will never exist. + const blockers = publishBlockers({ + manifests: [ + { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] }, + { + name: 'stash', + version: '1.0.1', + private: false, + workspaceDeps: [ + { table: 'dependencies', name: EQL, spec: 'workspace:^' }, + ], + }, + ], + lookup: (name) => (name === EQL ? ['3.0.4'] : ['1.0.0']), + frozen: new Map([[EQL, 'publisher not repointed yet']]), + }) + const range = blockers.find((b) => b.kind === 'frozen-dependency') + expect(range).toBeDefined() + expect(range.package).toBe('stash') + expect(range.dependency).toBe(EQL) + expect(range.range).toBe('^3.0.5') + }) + + it('allows a range only this same release will satisfy, when the dep can publish', () => { + // THE FALSE POSITIVE THAT WOULD MAKE THIS GATE UNUSABLE. Every ordinary + // release of this repo moves the six-package fixed group together, so at + // gate time `@cipherstash/stack-drizzle@1.0.1` depends on + // `@cipherstash/stack@1.0.1` and NEITHER is on npm yet. Failing that would + // freeze the repo permanently rather than catch anything. + expect( + publishBlockers({ + manifests: [ + { + name: 'stack', + version: '1.0.1', + private: false, + workspaceDeps: [], + }, + { + name: 'drizzle', + version: '1.0.1', + private: false, + workspaceDeps: [ + { table: 'dependencies', name: 'stack', spec: 'workspace:*' }, + ], + }, + ], + lookup: () => ['1.0.0'], + frozen: new Map(), + }), + ).toEqual([]) + }) + + it('blocks a runtime dependency on a package that is never published', () => { + // `@cipherstash/test-kit` is `private: true`. A runtime `workspace:*` on it + // packs a range for a package with no registry entry at all — the same + // broken install, arrived at a different way. + const blockers = publishBlockers({ + manifests: [ + { + name: 'test-kit', + version: '0.0.1', + private: true, + workspaceDeps: [], + }, + { + name: 'stack', + version: '1.0.0', + private: false, + workspaceDeps: [ + { table: 'dependencies', name: 'test-kit', spec: 'workspace:*' }, + ], + }, + ], + lookup: empty, + frozen: new Map(), + }) + expect(blockers.map((b) => b.kind)).toEqual(['private-dependency']) + }) + + it('blocks a hand-written range the workspace version cannot satisfy', () => { + // `workspace:^2.0.0` against a 1.x member. pnpm writes it out verbatim, so + // nothing downstream notices; it is simply a manifest that cannot resolve. + const blockers = publishBlockers({ + manifests: [ + { name: 'stack', version: '1.0.0', private: false, workspaceDeps: [] }, + { + name: 'drizzle', + version: '1.0.0', + private: false, + workspaceDeps: [ + { table: 'dependencies', name: 'stack', spec: 'workspace:^2.0.0' }, + ], + }, + ], + lookup: () => ['1.0.0'], + frozen: new Map(), + }) + expect(blockers.map((b) => b.kind)).toEqual(['unsatisfiable-range']) + }) + + it('ignores devDependencies', () => { + // A published tarball keeps its devDependencies in the manifest, but no + // consumer installs them, so an unsatisfiable one breaks nothing. This is + // why `packages/stack`'s `@cipherstash/eql: workspace:^` is not a finding + // while `packages/cli`'s identical line is. + expect( + publishBlockers({ + manifests: [ + { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] }, + { + name: 'stack', + version: '1.0.0', + private: false, + workspaceDeps: [ + { table: 'devDependencies', name: EQL, spec: 'workspace:^' }, + ], + }, + ], + lookup: (name) => (name === EQL ? ['3.0.4'] : ['1.0.0']), + frozen: new Map(), + }), + ).toEqual([]) + }) + + it('does not check a private package’s own dependencies', () => { + // `examples/*`, `e2e` and `packages/bench` are never packed, so their + // `workspace:*` lines reach no consumer. + expect( + publishBlockers({ + manifests: [ + { + name: 'test-kit', + version: '0.0.1', + private: true, + workspaceDeps: [], + }, + { + name: 'bench', + version: '0.0.5', + private: true, + workspaceDeps: [ + { table: 'dependencies', name: 'test-kit', spec: 'workspace:*' }, + ], + }, + ], + lookup: empty, + frozen: new Map(), + }), + ).toEqual([]) + }) + + it('propagates a lookup error instead of reporting "nothing blocks"', () => { + // The load-bearing direction, same as `unpublished`'s. A network, auth or + // rate-limit failure must stop the gate — swallowed, it reads as "this + // frozen package is already on npm", which is the one answer that lets the + // broken release through. + // + // The manifest carries a FROZEN package deliberately: that is what makes + // the registry answer load-bearing here. A package nothing asks about is + // not looked up at all, and `[]` is then the right answer whatever the + // registry is doing — so asserting the throw on that shape would pin an + // eager round trip rather than the property. + expect(() => + publishBlockers({ + manifests: [ + { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] }, + ], + lookup: () => { + throw new Error('npm view failed: ETIMEDOUT') + }, + frozen: new Map([[EQL, 'publisher not repointed yet']]), + }), + ).toThrow(/ETIMEDOUT/) + }) +}) + +describe('the gate over this repo’s real manifests', () => { + // A SYNTHETIC REGISTRY over the REAL tree: every workspace package is + // published at exactly the version the tree carries, EXCEPT `@cipherstash/eql` + // — stuck at 3.0.4, which is npm's actual state. So the only thing this can + // report is the consequence of the hand-applied 3.0.5 bump, and it reports it + // from the manifests themselves rather than from a fixture that could drift + // away from them. + const manifests = workspaceManifests() + const lookup = (name) => { + if (name === EQL) return ['3.0.3', '3.0.4'] + const found = manifests.find((m) => m.name === name) + return found ? [found.version] : null + } + const blockers = publishBlockers({ manifests, lookup }) + + it('names the frozen package that cannot publish', () => { + expect( + blockers + .filter((b) => b.kind === 'frozen-publisher') + .map((b) => `${b.package}@${b.version}`), + ).toEqual([`${EQL}@3.0.5`]) + }) + + it('names every published package that would ship the unsatisfiable range', () => { + // THE REGRESSION. `packages/cli` (`stash`) and `packages/stack-prisma` both + // carry `"@cipherstash/eql": "workspace:^"` under `dependencies`, so both + // pack `^3.0.5`. `packages/stack` carries the same line under + // `devDependencies` and must NOT appear. + expect( + blockers + .filter((b) => b.kind === 'frozen-dependency') + .map((b) => `${b.package} -> ${b.dependency}@${b.range}`) + .sort(), + ).toEqual([ + `@cipherstash/stack-prisma -> ${EQL}@^3.0.5`, + `stash -> ${EQL}@^3.0.5`, + ]) + }) + + it('reports nothing once the frozen package is on npm at its committed version', () => { + // The exit condition, stated as a test: complete the Phase-5 repoint and + // publish 3.0.5, and this gate goes quiet on its own. Nothing else has to + // change — which is what makes the freeze a fact about the registry rather + // than a policy encoded here. + expect( + publishBlockers({ + manifests, + lookup: (name) => (name === EQL ? ['3.0.4', '3.0.5'] : lookup(name)), + }), + ).toEqual([]) + }) +}) + +describe('the gate actually blocks the publish', () => { + const workflow = readWorkflow('.github/workflows/release.yml') + + it('skips the release job unless the gate job succeeded', () => { + // A gate that exits non-zero and stops nothing is a slower way of printing + // a warning. `release` is the job that runs `changeset publish`, and its + // condition is `always()` — needed, because `publish-ffi` is legitimately + // skipped — so "gate failed" has to be excluded EXPLICITLY or `always()` + // runs the publish straight through the failure. + const release = workflow.jobs.release + expect(release.needs).toContain('gate') + expect( + String(release.if), + "release.yml's `release` job must require `needs.gate.result == 'success'`. Under " + + '`always()` a failed gate would otherwise still reach `changeset publish`.', + ).toMatch(/needs\.gate\.result\s*==\s*'success'/) + }) +}) + +/** + * The gate as a PROCESS, driven against a fake registry. + * + * Every test above calls `publishBlockers` and reads what it returns. That + * proves the analysis and nothing about the release: a `main()` that computed + * the same list and exited 0 would pass all of them while publishing the broken + * tarballs. The exit code is the entire mechanism — `release.yml`'s `release` + * job is conditioned on `needs.gate.result == 'success'` — so it gets a test + * that actually runs the script. + * + * `npm` is shimmed on PATH rather than the module being imported, because + * `npmVersions` shells out to it. That also keeps this offline and + * deterministic: the real registry would make the assertion below depend on + * whether Phase 5 has happened yet. + */ +describe('the gate exits non-zero when a blocker is found', () => { + const manifests = workspaceManifests() + + /** A PATH entry whose `npm view versions --json` answers from `map`. */ + const fakeRegistry = (map) => { + const dir = mkdtempSync(join(tmpdir(), 'release-gate-')) + const versions = join(dir, 'versions.json') + writeFileSync(versions, JSON.stringify(map)) + const shim = join(dir, 'npm') + writeFileSync( + shim, + '#!/usr/bin/env node\n' + + "const map = JSON.parse(require('node:fs').readFileSync(process.env.FAKE_NPM_VERSIONS, 'utf8'))\n" + + 'const found = map[process.argv[3]]\n' + + "if (!found) { process.stderr.write('npm error code E404\\n'); process.exit(1) }\n" + + 'process.stdout.write(JSON.stringify(found))\n', + ) + chmodSync(shim, 0o755) + return { dir, versions } + } + + /** Every workspace package published at exactly its committed version. */ + const allPublished = Object.fromEntries( + manifests.map(({ name, version }) => [name, [version]]), + ) + + const runGate = (map) => { + const { dir, versions } = fakeRegistry(map) + const result = spawnSync(process.execPath, ['scripts/release-gate.mjs'], { + cwd: REPO_ROOT, + encoding: 'utf8', + env: { + ...process.env, + PATH: `${dir}:${process.env.PATH}`, + FAKE_NPM_VERSIONS: versions, + // The real one would be written for the whole vitest run. + GITHUB_OUTPUT: join(dir, 'github-output.txt'), + }, + }) + rmSync(dir, { recursive: true, force: true }) + return result + } + + it('fails the job, and says how to clear it', () => { + // TODAY'S TREE against TODAY'S REGISTRY: @cipherstash/eql pinned to 3.0.4, + // everything else current. Exit 1 is what skips the `release` job. + const result = runGate({ ...allPublished, [EQL]: ['3.0.3', '3.0.4'] }) + expect(result.status).toBe(1) + expect(result.stderr).toContain('cannot be installed') + expect(result.stderr).toContain(`${EQL}@3.0.5`) + // The message has to name the way out, or a blocked release is a puzzle. + expect(result.stderr).toContain('Phase 5') + }) + + it('still reports the publish set on the run it blocks', () => { + // The `ffi`/`js` outputs are diagnostic and are written BEFORE the exit, so + // the job log on a blocked run still says what was missing. Losing that + // would make the blocked run less informative than a passing one. + const result = runGate({ ...allPublished, [EQL]: ['3.0.3', '3.0.4'] }) + expect(result.stdout).toContain(`unpublished: ${EQL}`) + }) + + it('exits 0 once the frozen package is published', () => { + // The other half of the mutation check: this must not be a gate that always + // fails. Publish 3.0.5 and the same tree passes untouched. + const result = runGate({ ...allPublished, [EQL]: ['3.0.4', '3.0.5'] }) + expect(result.stderr).toBe('') + expect(result.status).toBe(0) + }) +}) diff --git a/scripts/__tests__/release-version-hook.test.mjs b/scripts/__tests__/release-version-hook.test.mjs index fe6a8cbd4..9ec564197 100644 --- a/scripts/__tests__/release-version-hook.test.mjs +++ b/scripts/__tests__/release-version-hook.test.mjs @@ -104,3 +104,69 @@ describe('the root `version` script chains the propagation', () => { ).toBeLessThan(script.indexOf(VERSION_SCRIPT)) }) }) + +/** + * The same hook, reached the way a human reaches it. + * + * `release.yml` is not the only caller. `AGENTS.md` documents the release flow + * as `pnpm changeset:version`, and that alias was a bare `changeset version` — + * so a maintainer following this repo's own documentation reproduced exactly + * the skew the hook exists to prevent: npm bumped, the crate and the bundled + * SQL left behind. The workflow test above passes throughout, because the + * workflow is not what ran. + * + * The rule is stated over the SCRIPTS rather than over the one name, so a + * second convenience alias added later is held to it without anyone + * remembering this file exists. Two changeset commands are wrapped by this + * repo, and both wrappers are load-bearing: + * + * * `changeset version` must chain `sync-lockstep-versions.mjs`, or the + * lockstep bump reaches npm and nothing else. + * * `changeset publish` must build first, or it packs whatever `dist/` the + * working tree happens to hold — which for a clean clone is nothing. + * + * A script that wraps neither (`pnpm run version`, `pnpm run release`) is not + * matched and needs no exemption: it does not contain the bare command. + */ +describe('no root script invokes a bare changesets command', () => { + const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8')) + const scripts = Object.entries(pkg.scripts ?? {}) + + /** Scripts whose body runs `changeset `, other than via `pnpm run`. */ + const invoking = (command) => + scripts.filter(([, body]) => + new RegExp(`(^|[\\s;&|(])changeset\\s+${command}\\b`).test(body), + ) + + it('finds the wrappers it is checking', () => { + // The floor. Both rules below are "for every script that runs X…", and a + // repo where nothing matches passes them having checked nothing — which is + // also what a rename of the changesets CLI would produce. + expect(invoking('version').length).toBeGreaterThan(0) + expect(invoking('publish').length).toBeGreaterThan(0) + }) + + it('chains the lockstep sync onto every `changeset version`', () => { + const offenders = invoking('version') + .filter(([, body]) => !body.includes(VERSION_SCRIPT)) + .map(([name, body]) => `${name}: ${body}`) + expect( + offenders, + `A root script runs \`changeset version\` without ${VERSION_SCRIPT}. It bumps the npm ` + + 'package and leaves packages/eql/crates/eql-bindings/Cargo.toml, every Cargo.lock that ' + + 'records it, and the bundled SQL at the previous version. Route the alias through ' + + '`pnpm run version` instead of calling the changesets CLI directly.', + ).toEqual([]) + }) + + it('builds before every `changeset publish`', () => { + const offenders = invoking('publish') + .filter(([, body]) => !/\brun build\b/.test(body)) + .map(([name, body]) => `${name}: ${body}`) + expect( + offenders, + 'A root script runs `changeset publish` without building first, so it packs whatever ' + + '`dist/` the working tree happens to hold. Route the alias through `pnpm run release`.', + ).toEqual([]) + }) +}) diff --git a/scripts/__tests__/sync-lockstep-versions.test.mjs b/scripts/__tests__/sync-lockstep-versions.test.mjs index 2d4192c61..d00f57533 100644 --- a/scripts/__tests__/sync-lockstep-versions.test.mjs +++ b/scripts/__tests__/sync-lockstep-versions.test.mjs @@ -1,5 +1,12 @@ import { describe, expect, test } from 'vitest' -import { bumpCargoPackageVersion } from '../sync-lockstep-versions.mjs' +import { + bumpCargoPackageVersion, + cargoLockWorkspaces, + LOCKED_CRATE, + refreshCargoLock, +} from '../sync-lockstep-versions.mjs' +import { REPO_ROOT } from './lib/repo-root.mjs' +import { readWorkflow } from './lib/workflows.mjs' const CARGO = `[package] name = "eql-bindings" @@ -56,3 +63,138 @@ serde_json = "1" expect(out).toContain('serde_json = "1"') }) }) + +/** One `refreshCargoLock` call, as `[command, args, options]`. */ +function captureRefresh() { + const calls = [] + refreshCargoLock({ + root: '/repo', + eqlRoot: '/repo/packages/eql', + workspace: 'packages/protect-ffi', + run: (...args) => calls.push(args), + }) + expect(calls).toHaveLength(1) + return calls[0] +} + +/** + * The second thing the lockstep bump has to carry, and the one it did not. + * + * Rewriting `packages/eql/crates/eql-bindings/Cargo.toml` moves the crate's + * version. Every `Cargo.lock` that resolves that crate FROM A PATH records the + * old one, and nothing in this repo passes `--locked`, so the stale lock is + * regenerated on every CI run, used, and discarded — green the whole way. + * `cargo metadata --locked` in `packages/protect-ffi` exited 101 for exactly + * this reason after the 3.0.5 bump. + * + * `scripts/__tests__/cargo-lock-freshness.test.mjs` is the guard that fails a + * PR carrying a stale lock. These are the tests for the half that stops it + * going stale in the first place. + */ +describe('lockstep Cargo.lock refresh', () => { + test('discovers every lock that resolves the crate from this tree', () => { + const found = cargoLockWorkspaces(REPO_ROOT) + + // The floor. Discovery over a hardcoded list means a walk that stops + // matching refreshes nothing and reports success — so an empty result is a + // failure, not a no-op. `packages/protect-ffi` is named because it is the + // consumer that broke: it path-depends on the crate from a SEPARATE cargo + // workspace, so no eql-side build ever touches its lock. + expect(found.length).toBeGreaterThan(0) + expect(found).toContain('packages/protect-ffi') + }) + + test('refreshes through mise, against the named workspace', () => { + const [command, args, options] = captureRefresh() + + // THROUGH MISE, not a bare `cargo`. release.yml installs mise with + // `add_shims_to_path: false` — deliberately, so mise's own Node cannot + // shadow the one `changeset publish` needs — which means cargo is NOT on + // PATH in the release job. `mise exec` resolves it from + // packages/eql/mise.toml's `[tools] rust`, which is the same toolchain the + // SQL build below uses. + expect(command).toBe('mise') + expect(args.slice(0, 3)).toEqual(['exec', '--', 'cargo']) + expect(options.cwd).toBe('/repo/packages/eql') + + expect(args).toContain('--package') + expect(args).toContain(LOCKED_CRATE) + expect(args).toContain('--manifest-path') + expect(args).toContain('/repo/packages/protect-ffi/Cargo.toml') + }) + + /** + * NOT `--offline`, and the reason is a property of the job this runs in. + * + * `--offline` reads as free here — `eql-bindings` resolves from a path, so + * why would refreshing it need a registry? Because `cargo update -p X` does + * not update X in isolation: it re-resolves the WHOLE graph and rewrites a + * complete lock, and in offline mode every other package has to come from + * the local registry cache. `packages/protect-ffi` has 167 of them. + * + * The release job has no such cache. `jdx/mise-action` runs there with + * `install: true, cache: false` — it installs toolchains and populates + * nothing under `~/.cargo/registry` — and + * `scripts/lint-no-workflow-caching.mjs` forbids any cache restore in a + * workflow that publishes. So the first call dies: + * + * error: no matching package named `chrono` found + * location searched: crates.io index + * + * — with `execFileSync` throwing, `pnpm run version` failing, and no Version + * Packages PR, AFTER `changeset version` has already rewritten every manifest + * and CHANGELOG in a job holding `contents: write`. That is the same + * half-applied-release failure the mise-install step above exists to prevent. + * + * The measurement that made `--offline` look safe was taken on a developer + * machine with a warm `~/.cargo`. Both resolutions agree — verified on the + * 3.0.4 -> 3.0.5 bump, byte-identical including the `windows-sys` edges cargo + * repaired along the way — so dropping the flag changes nothing except + * whether the step can run at all where it actually runs. + */ + test('does not pass --offline, which cannot resolve on a cold registry', () => { + const [, args] = captureRefresh() + expect(args).not.toContain('--offline') + }) + + test('the release job offers no warm cargo registry to resolve against', () => { + // The other half of the pair above, asserted against CI rather than + // restated in a comment: if this ever stops being true — someone warms the + // registry deliberately — then `--offline` becomes available again, and + // the test that forbids it should be revisited rather than worked around. + const steps = readWorkflow('.github/workflows/release.yml').jobs.release + .steps + + const mise = steps.find((s) => + (s.uses ?? '').startsWith('jdx/mise-action@'), + ) + expect(mise, 'release.yml no longer installs mise').toBeDefined() + expect(mise.with.cache).toBe(false) + + expect( + steps.filter((s) => /\bactions\/cache\b/.test(s.uses ?? '')), + 'a cache restore in the publishing workflow', + ).toEqual([]) + + expect( + steps.filter((s) => /cargo\s+(fetch|vendor)/.test(s.run ?? '')), + 'a step that warms the cargo registry', + ).toEqual([]) + }) + + test('fails loudly rather than leaving a lock stale', () => { + // A refresh that cannot run must stop the release. The alternative is the + // state this whole pair of tests exists to end: a bumped manifest, a lock + // that still names the old version, and a green log. + expect(() => + refreshCargoLock({ + root: '/repo', + eqlRoot: '/repo/packages/eql', + workspace: 'packages/protect-ffi', + run: () => { + throw new Error('spawn mise ENOENT') + }, + }), + ).toThrow(/ENOENT/) + }) +}) diff --git a/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs b/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs index e1ea3565d..3fc7dee8d 100644 --- a/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs +++ b/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs @@ -559,8 +559,9 @@ describe('the fork-PR guard keeps its meaning', () => { // Every context, then narrowed to the ones this workflow can actually be // in. A workflow with no `push:` trigger is never evaluated on a push, so // requiring `push: true` there would be asserting about a run that cannot - // happen — and `test-eql.yml` deliberately has no `push:` (its merge queue - // already validated the exact merge commit). + // happen. (`test-eql.yml` carried no `push:` when this was written, + // justified by a merge queue that does not exist in this repository; it + // has one now, and this narrowing simply picks the trigger up.) // // `workflow_dispatch` is the exception and stays unconditional: this file // exists because a job silently skipped on a dispatch that WAS declared, diff --git a/scripts/__tests__/workflow-grep-q-pipelines.test.mjs b/scripts/__tests__/workflow-grep-q-pipelines.test.mjs index 7d0b3401b..5061dcf26 100644 --- a/scripts/__tests__/workflow-grep-q-pipelines.test.mjs +++ b/scripts/__tests__/workflow-grep-q-pipelines.test.mjs @@ -1,4 +1,5 @@ -import { readdirSync } from 'node:fs' +import { execFileSync } from 'node:child_process' +import { readdirSync, readFileSync } from 'node:fs' import { join } from 'node:path' import { describe, expect, it } from 'vitest' import { REPO_ROOT } from './lib/repo-root.mjs' @@ -36,6 +37,20 @@ import { readWorkflow, workflowFiles } from './lib/workflows.mjs' * * `grep -q` reading a FILE or a here-string is fine and stays allowed — there * is no writer to signal. Only pipelines are rejected. + * + * The second `describe` below extends the same rule to tracked shell scripts, + * because the hazard is a property of the shell and not of GitHub Actions. + * `packages/eql/tasks/test/docs_v3_grep.sh` had it in the fail-OPEN direction: + * + * elif tasks/docs/doxygen-filter.sh src/v3/json/functions.sql | grep -q 'ste_vec_contains' + * + * On the failure path — the deprecated aliases DO leak through the Doxygen + * filter — grep matched, exited 0, and closed the pipe; awk took SIGPIPE, the + * pipeline reported 141 under `set -o pipefail`, the `elif` was false, and the + * FAIL branch never ran. Only the clean case was reported correctly, so the + * guard could only ever say "OK". Measured at 141 against the real 16 KB filter + * output on macOS, whose pipe buffer starts at 16 KB; Linux's 64 KB buffer hid + * it, which is exactly the platform split the tar case above describes. */ /** Composite actions are part of the same call tree, and run the same shells. */ @@ -72,6 +87,15 @@ function runBlocks(doc, file) { */ const PIPED_QUIET_GREP = /\|\s*grep\s+(?:-[a-zA-Z]*q[a-zA-Z]*|--quiet)\b/ +/** + * Whole-line `#` comments are not code, and the rule has to survive being + * WRITTEN DOWN: the fix comment on `docs_v3_grep.sh` quotes the very pipeline + * it replaced, and without this the guard reported the explanation as the + * defect. Only leading-`#` lines are skipped — stripping `#` to end-of-line + * would eat it out of grep patterns and quoted strings. + */ +const isComment = (line) => /^\s*#/.test(line) + describe('no run: block pipes into grep -q', () => { const files = [...workflowFiles(), ...actionManifests()] @@ -85,7 +109,9 @@ describe('no run: block pipes into grep -q', () => { run .split('\n') .map((line, i) => ({ where, line: line.trim(), number: i + 1 })) - .filter(({ line }) => PIPED_QUIET_GREP.test(line)), + .filter( + ({ line }) => !isComment(line) && PIPED_QUIET_GREP.test(line), + ), ) .map((hit) => `${file} › ${hit.where} › line ${hit.number}: ${hit.line}`), ) @@ -94,3 +120,88 @@ describe('no run: block pipes into grep -q', () => { expect(offenders).toEqual([]) }) }) + +/** + * `echo` and `printf` writing a bounded diagnostic string — an error message, a + * captured comment block — are exempt: the whole write lands in the pipe buffer + * before grep can exit, so there is no blocked writer left to signal. The + * exemption is about SIZE, not about them being builtins (a builtin in a + * pipeline still runs in a subshell and still takes SIGPIPE), so `echo "$x"` + * where `$x` could grow past a pipe buffer would reintroduce the hazard. Every + * exempted call site in this tree pipes a short, known-bounded string. + */ +const BOUNDED_WRITERS = new Set(['echo', 'printf']) + +/** The first word of the command immediately upstream of the `| grep -q`. */ +function upstreamWriter(line) { + const match = line.match(PIPED_QUIET_GREP) + if (!match) return null + const feeding = line.slice(0, match.index).split('|').pop() ?? '' + let head = feeding.trim() + let previous + do { + previous = head + head = head + .replace(/^(?:!|if|elif|while|until|then|do|&&|\|\||;)\s*/, '') + .trim() + } while (head !== previous) + return head.split(/\s+/)[0] ?? '' +} + +/** Tracked shell scripts, via git so it honours .gitignore. */ +function shellScripts() { + return execFileSync('git', ['ls-files', '-z', '--', '*.sh'], { + cwd: REPO_ROOT, + encoding: 'utf8', + }) + .split('\0') + .filter(Boolean) +} + +describe('no shell script pipes an unbounded writer into grep -q', () => { + const scripts = shellScripts() + + it('finds shell scripts to check', () => { + expect(scripts.length).toBeGreaterThan(0) + expect(scripts).toContain('packages/eql/tasks/test/docs_v3_grep.sh') + }) + + it('parses the upstream writer out of a pipeline', () => { + // The classifier is what decides whether a line is reported, so a bug in it + // silently empties the check below. + expect(upstreamWriter('if ! echo "$b" | grep -q "@brief"; then')).toBe( + 'echo', + ) + expect(upstreamWriter("printf '%s' \"$err\" | grep -qi 'HTTP 404'")).toBe( + 'printf', + ) + expect( + upstreamWriter("elif tasks/docs/doxygen-filter.sh x.sql | grep -q 'y'"), + ).toBe('tasks/docs/doxygen-filter.sh') + expect(upstreamWriter('cat f | tr a b | grep -q x')).toBe('tr') + expect(upstreamWriter('grep -q x file')).toBeNull() + expect(isComment(' # never `foo.sh | grep -q bar`')).toBe(true) + expect(isComment('grep -q \'#tag\' <<< "$x"')).toBe(false) + }) + + const offenders = scripts.flatMap((file) => + readFileSync(join(REPO_ROOT, file), 'utf8') + .split('\n') + .map((line, i) => ({ line: line.trim(), number: i + 1 })) + .filter(({ line }) => { + if (isComment(line)) return false + const writer = upstreamWriter(line) + return writer !== null && !BOUNDED_WRITERS.has(writer) + }) + .map((hit) => `${file}:${hit.number}: ${hit.line}`), + ) + + it('has none', () => { + expect( + offenders, + 'Capture the output first and match against the variable:\n' + + ' out=$(producer)\n' + + ' grep -q pattern <<< "$out"', + ).toEqual([]) + }) +}) diff --git a/scripts/__tests__/workflow-mise-setup.test.mjs b/scripts/__tests__/workflow-mise-setup.test.mjs new file mode 100644 index 000000000..e8489691f --- /dev/null +++ b/scripts/__tests__/workflow-mise-setup.test.mjs @@ -0,0 +1,235 @@ +import { existsSync, readFileSync } from 'node:fs' +import { join } from 'node:path' +import { describe, expect, it } from 'vitest' +import { REPO_ROOT } from './lib/repo-root.mjs' +import { readWorkflow, workflowFiles } from './lib/workflows.mjs' + +/** + * A job whose command chain reaches `mise` must install mise, first. + * + * ## Why this fails open, and silently, without a test + * + * `mise` is NOT preinstalled on GitHub's ubuntu runner images. A job that needs + * it and does not install it fails with `ENOENT: spawn mise` — which is loud + * enough, once it runs. The problem is *when* it runs. + * + * `release.yml`'s `release` job passes `version: pnpm run version` to + * `changesets/action`. That input is a shell command, and the chain behind it + * is three hops deep and entirely invisible in the workflow file: + * + * version: pnpm run version (release.yml) + * -> "changeset version && node scripts/sync-lockstep-versions.mjs" + * (root package.json) + * -> execFileSync('mise', ['run', 'release:prepare_bindings_assets'…]) + * (that script) + * + * Nothing in `release.yml` says the word `mise`. The job installed pnpm, Node, + * node-gyp and npm and looked complete. And the branch that runs the hook — + * changesets taking its VERSION branch, which it does only when `.changeset/` + * holds unconsumed changesets — is not the branch a release rehearsal + * exercises, so the gap survived review of both the workflow and the script. + * + * The cost of finding out at run time is what makes this a test rather than a + * comment: `changeset version` runs FIRST and rewrites every manifest and + * changelog in the tree. The ENOENT lands after that, so the failure is a + * half-applied version bump in a job holding `contents: write`, and the repair + * is manual. + * + * ## What is checked + * + * The chain is RESOLVED, not pattern-matched, because the whole defect is that + * the requirement is not visible at the call site. `pnpm run